1# coding: UTF-8 2# :markup: markdown 3 4## 5# RDoc::Markdown as described by the [markdown syntax][syntax]. 6# 7# To choose Markdown as your only default format see 8# RDoc::Options@Saved+Options for instructions on setting up a `.doc_options` 9# file to store your project default. 10# 11# ## Extensions 12# 13# The following markdown extensions are supported by the parser, but not all 14# are used in RDoc output by default. 15# 16# ### RDoc 17# 18# The RDoc Markdown parser has the following built-in behaviors that cannot be 19# disabled. 20# 21# Underscores embedded in words are never interpreted as emphasis. (While the 22# [markdown dingus][dingus] emphasizes in-word underscores, neither the 23# Markdown syntax nor MarkdownTest mention this behavior.) 24# 25# For HTML output, RDoc always auto-links bare URLs. 26# 27# ### Break on Newline 28# 29# The break_on_newline extension converts all newlines into hard line breaks 30# as in [Github Flavored Markdown][GFM]. This extension is disabled by 31# default. 32# 33# ### CSS 34# 35# The #css extension enables CSS blocks to be included in the output, but they 36# are not used for any built-in RDoc output format. This extension is disabled 37# by default. 38# 39# Example: 40# 41# <style type="text/css"> 42# h1 { font-size: 3em } 43# </style> 44# 45# ### Definition Lists 46# 47# The definition_lists extension allows definition lists using the [PHP 48# Markdown Extra syntax][PHPE], but only one label and definition are supported 49# at this time. This extension is enabled by default. 50# 51# Example: 52# 53# ``` 54# cat 55# : A small furry mammal 56# that seems to sleep a lot 57# 58# ant 59# : A little insect that is known 60# to enjoy picnics 61# 62# ``` 63# 64# Produces: 65# 66# cat 67# : A small furry mammal 68# that seems to sleep a lot 69# 70# ant 71# : A little insect that is known 72# to enjoy picnics 73# 74# ### Github 75# 76# The #github extension enables a partial set of [Github Flavored Markdown] 77# [GFM]. This extension is enabled by default. 78# 79# Supported github extensions include: 80# 81# #### Fenced code blocks 82# 83# Use ` ``` ` around a block of code instead of indenting it four spaces. 84# 85# #### Syntax highlighting 86# 87# Use ` ``` ruby ` as the start of a code fence to add syntax highlighting. 88# (Currently only `ruby` syntax is supported). 89# 90# ### HTML 91# 92# Enables raw HTML to be included in the output. This extension is enabled by 93# default. 94# 95# Example: 96# 97# <table> 98# ... 99# </table> 100# 101# ### Notes 102# 103# The #notes extension enables footnote support. This extension is enabled by 104# default. 105# 106# Example: 107# 108# Here is some text[^1] including an inline footnote ^[for short footnotes] 109# 110# ... 111# 112# [^1]: With the footnote text down at the bottom 113# 114# Produces: 115# 116# Here is some text[^1] including an inline footnote ^[for short footnotes] 117# 118# [^1]: With the footnote text down at the bottom 119# 120# ## Limitations 121# 122# * Link titles are not used 123# * Image links are not generated correctly 124# * Footnotes are collapsed into a single paragraph 125# 126# ## Author 127# 128# This markdown parser is a port to kpeg from [peg-markdown][pegmarkdown] by 129# John MacFarlane. 130# 131# It is used under the MIT license: 132# 133# Permission is hereby granted, free of charge, to any person obtaining a copy 134# of this software and associated documentation files (the "Software"), to deal 135# in the Software without restriction, including without limitation the rights 136# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 137# copies of the Software, and to permit persons to whom the Software is 138# furnished to do so, subject to the following conditions: 139# 140# The above copyright notice and this permission notice shall be included in 141# all copies or substantial portions of the Software. 142# 143# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 144# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 145# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 146# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 147# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 148# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 149# THE SOFTWARE. 150# 151# The port to kpeg was performed by Eric Hodel and Evan Phoenix 152# 153# [dingus]: http://daringfireball.net/projects/markdown/dingus 154# [GFM]: http://github.github.com/github-flavored-markdown/ 155# [pegmarkdown]: https://github.com/jgm/peg-markdown 156# [PHPE]: http://michelf.com/projects/php-markdown/extra/#def-list 157# [syntax]: http://daringfireball.net/projects/markdown/syntax 158#-- 159# Last updated to jgm/peg-markdown commit 8f8fc22ef0 160class RDoc::Markdown 161 # :stopdoc: 162 163 # This is distinct from setup_parser so that a standalone parser 164 # can redefine #initialize and still have access to the proper 165 # parser setup code. 166 def initialize(str, debug=false) 167 setup_parser(str, debug) 168 end 169 170 171 172 # Prepares for parsing +str+. If you define a custom initialize you must 173 # call this method before #parse 174 def setup_parser(str, debug=false) 175 @string = str 176 @pos = 0 177 @memoizations = Hash.new { |h,k| h[k] = {} } 178 @result = nil 179 @failed_rule = nil 180 @failing_rule_offset = -1 181 182 setup_foreign_grammar 183 end 184 185 attr_reader :string 186 attr_reader :failing_rule_offset 187 attr_accessor :result, :pos 188 189 190 def current_column(target=pos) 191 if c = string.rindex("\n", target-1) 192 return target - c - 1 193 end 194 195 target + 1 196 end 197 198 def current_line(target=pos) 199 cur_offset = 0 200 cur_line = 0 201 202 string.each_line do |line| 203 cur_line += 1 204 cur_offset += line.size 205 return cur_line if cur_offset >= target 206 end 207 208 -1 209 end 210 211 def lines 212 lines = [] 213 string.each_line { |l| lines << l } 214 lines 215 end 216 217 218 219 def get_text(start) 220 @string[start..@pos-1] 221 end 222 223 def show_pos 224 width = 10 225 if @pos < width 226 "#{@pos} (\"#{@string[0,@pos]}\" @ \"#{@string[@pos,width]}\")" 227 else 228 "#{@pos} (\"... #{@string[@pos - width, width]}\" @ \"#{@string[@pos,width]}\")" 229 end 230 end 231 232 def failure_info 233 l = current_line @failing_rule_offset 234 c = current_column @failing_rule_offset 235 236 if @failed_rule.kind_of? Symbol 237 info = self.class::Rules[@failed_rule] 238 "line #{l}, column #{c}: failed rule '#{info.name}' = '#{info.rendered}'" 239 else 240 "line #{l}, column #{c}: failed rule '#{@failed_rule}'" 241 end 242 end 243 244 def failure_caret 245 l = current_line @failing_rule_offset 246 c = current_column @failing_rule_offset 247 248 line = lines[l-1] 249 "#{line}\n#{' ' * (c - 1)}^" 250 end 251 252 def failure_character 253 l = current_line @failing_rule_offset 254 c = current_column @failing_rule_offset 255 lines[l-1][c-1, 1] 256 end 257 258 def failure_oneline 259 l = current_line @failing_rule_offset 260 c = current_column @failing_rule_offset 261 262 char = lines[l-1][c-1, 1] 263 264 if @failed_rule.kind_of? Symbol 265 info = self.class::Rules[@failed_rule] 266 "@#{l}:#{c} failed rule '#{info.name}', got '#{char}'" 267 else 268 "@#{l}:#{c} failed rule '#{@failed_rule}', got '#{char}'" 269 end 270 end 271 272 class ParseError < RuntimeError 273 end 274 275 def raise_error 276 raise ParseError, failure_oneline 277 end 278 279 def show_error(io=STDOUT) 280 error_pos = @failing_rule_offset 281 line_no = current_line(error_pos) 282 col_no = current_column(error_pos) 283 284 io.puts "On line #{line_no}, column #{col_no}:" 285 286 if @failed_rule.kind_of? Symbol 287 info = self.class::Rules[@failed_rule] 288 io.puts "Failed to match '#{info.rendered}' (rule '#{info.name}')" 289 else 290 io.puts "Failed to match rule '#{@failed_rule}'" 291 end 292 293 io.puts "Got: #{string[error_pos,1].inspect}" 294 line = lines[line_no-1] 295 io.puts "=> #{line}" 296 io.print(" " * (col_no + 3)) 297 io.puts "^" 298 end 299 300 def set_failed_rule(name) 301 if @pos > @failing_rule_offset 302 @failed_rule = name 303 @failing_rule_offset = @pos 304 end 305 end 306 307 attr_reader :failed_rule 308 309 def match_string(str) 310 len = str.size 311 if @string[pos,len] == str 312 @pos += len 313 return str 314 end 315 316 return nil 317 end 318 319 def scan(reg) 320 if m = reg.match(@string[@pos..-1]) 321 width = m.end(0) 322 @pos += width 323 return true 324 end 325 326 return nil 327 end 328 329 if "".respond_to? :getbyte 330 def get_byte 331 if @pos >= @string.size 332 return nil 333 end 334 335 s = @string.getbyte @pos 336 @pos += 1 337 s 338 end 339 else 340 def get_byte 341 if @pos >= @string.size 342 return nil 343 end 344 345 s = @string[@pos] 346 @pos += 1 347 s 348 end 349 end 350 351 def parse(rule=nil) 352 # We invoke the rules indirectly via apply 353 # instead of by just calling them as methods because 354 # if the rules use left recursion, apply needs to 355 # manage that. 356 357 if !rule 358 apply(:_root) 359 else 360 method = rule.gsub("-","_hyphen_") 361 apply :"_#{method}" 362 end 363 end 364 365 class MemoEntry 366 def initialize(ans, pos) 367 @ans = ans 368 @pos = pos 369 @result = nil 370 @set = false 371 @left_rec = false 372 end 373 374 attr_reader :ans, :pos, :result, :set 375 attr_accessor :left_rec 376 377 def move!(ans, pos, result) 378 @ans = ans 379 @pos = pos 380 @result = result 381 @set = true 382 @left_rec = false 383 end 384 end 385 386 def external_invoke(other, rule, *args) 387 old_pos = @pos 388 old_string = @string 389 390 @pos = other.pos 391 @string = other.string 392 393 begin 394 if val = __send__(rule, *args) 395 other.pos = @pos 396 other.result = @result 397 else 398 other.set_failed_rule "#{self.class}##{rule}" 399 end 400 val 401 ensure 402 @pos = old_pos 403 @string = old_string 404 end 405 end 406 407 def apply_with_args(rule, *args) 408 memo_key = [rule, args] 409 if m = @memoizations[memo_key][@pos] 410 @pos = m.pos 411 if !m.set 412 m.left_rec = true 413 return nil 414 end 415 416 @result = m.result 417 418 return m.ans 419 else 420 m = MemoEntry.new(nil, @pos) 421 @memoizations[memo_key][@pos] = m 422 start_pos = @pos 423 424 ans = __send__ rule, *args 425 426 lr = m.left_rec 427 428 m.move! ans, @pos, @result 429 430 # Don't bother trying to grow the left recursion 431 # if it's failing straight away (thus there is no seed) 432 if ans and lr 433 return grow_lr(rule, args, start_pos, m) 434 else 435 return ans 436 end 437 438 return ans 439 end 440 end 441 442 def apply(rule) 443 if m = @memoizations[rule][@pos] 444 @pos = m.pos 445 if !m.set 446 m.left_rec = true 447 return nil 448 end 449 450 @result = m.result 451 452 return m.ans 453 else 454 m = MemoEntry.new(nil, @pos) 455 @memoizations[rule][@pos] = m 456 start_pos = @pos 457 458 ans = __send__ rule 459 460 lr = m.left_rec 461 462 m.move! ans, @pos, @result 463 464 # Don't bother trying to grow the left recursion 465 # if it's failing straight away (thus there is no seed) 466 if ans and lr 467 return grow_lr(rule, nil, start_pos, m) 468 else 469 return ans 470 end 471 472 return ans 473 end 474 end 475 476 def grow_lr(rule, args, start_pos, m) 477 while true 478 @pos = start_pos 479 @result = m.result 480 481 if args 482 ans = __send__ rule, *args 483 else 484 ans = __send__ rule 485 end 486 return nil unless ans 487 488 break if @pos <= m.pos 489 490 m.move! ans, @pos, @result 491 end 492 493 @result = m.result 494 @pos = m.pos 495 return m.ans 496 end 497 498 class RuleInfo 499 def initialize(name, rendered) 500 @name = name 501 @rendered = rendered 502 end 503 504 attr_reader :name, :rendered 505 end 506 507 def self.rule_info(name, rendered) 508 RuleInfo.new(name, rendered) 509 end 510 511 512 # :startdoc: 513 514 515 516 require 'rubygems' 517 require 'rdoc' 518 require 'rdoc/markup/to_joined_paragraph' 519 require 'rdoc/markdown/entities' 520 521 if RUBY_VERSION > '1.9' then 522 require 'rdoc/markdown/literals_1_9' 523 else 524 require 'rdoc/markdown/literals_1_8' 525 end 526 527 ## 528 # Supported extensions 529 530 EXTENSIONS = [] 531 532 ## 533 # Extensions enabled by default 534 535 DEFAULT_EXTENSIONS = [ 536 :definition_lists, 537 :github, 538 :html, 539 :notes, 540 ] 541 542 # :section: Extensions 543 544 ## 545 # Creates extension methods for the `name` extension to enable and disable 546 # the extension and to query if they are active. 547 548 def self.extension name 549 EXTENSIONS << name 550 551 eval <<-RUBY 552 def #{name}? 553 extension? __method__ 554 end 555 556 def #{name}= enable 557 extension __method__, enable 558 end 559 RUBY 560 end 561 562 ## 563 # Converts all newlines into hard breaks 564 565 extension :break_on_newline 566 567 ## 568 # Allow style blocks 569 570 extension :css 571 572 ## 573 # Allow PHP Markdown Extras style definition lists 574 575 extension :definition_lists 576 577 ## 578 # Allow Github Flavored Markdown 579 580 extension :github 581 582 ## 583 # Allow HTML 584 585 extension :html 586 587 ## 588 # Enables the notes extension 589 590 extension :notes 591 592 # :section: 593 594 ## 595 # Parses the `markdown` document into an RDoc::Document using the default 596 # extensions. 597 598 def self.parse markdown 599 parser = new 600 601 parser.parse markdown 602 end 603 604 # TODO remove when kpeg 0.10 is released 605 alias orig_initialize initialize # :nodoc: 606 607 ## 608 # Creates a new markdown parser that enables the given +extensions+. 609 610 def initialize extensions = DEFAULT_EXTENSIONS, debug = false 611 @debug = debug 612 @formatter = RDoc::Markup::ToJoinedParagraph.new 613 @extensions = extensions 614 615 @references = nil 616 @unlinked_references = nil 617 618 @footnotes = nil 619 @note_order = nil 620 end 621 622 ## 623 # Wraps `text` in emphasis for rdoc inline formatting 624 625 def emphasis text 626 if text =~ /\A[a-z\d.\/]+\z/i then 627 "_#{text}_" 628 else 629 "<em>#{text}</em>" 630 end 631 end 632 633 ## 634 # :category: Extensions 635 # 636 # Is the extension `name` enabled? 637 638 def extension? name 639 name = name.to_s.delete('?').intern 640 641 @extensions.include? name 642 end 643 644 ## 645 # :category: Extensions 646 # 647 # Enables or disables the extension with `name` 648 649 def extension name, enable 650 name = name.to_s.delete('=').intern 651 652 if enable then 653 @extensions |= [name] 654 else 655 @extensions -= [name] 656 end 657 end 658 659 ## 660 # Parses `text` in a clone of this parser. This is used for handling nested 661 # lists the same way as markdown_parser. 662 663 def inner_parse text # :nodoc: 664 parser = clone 665 666 parser.setup_parser text, @debug 667 668 parser.peg_parse 669 670 doc = parser.result 671 672 doc.accept @formatter 673 674 doc.parts 675 end 676 677 ## 678 # Finds a link reference for `label` and creates a new link to it with 679 # `content` as the link text. If `label` was not encountered in the 680 # reference-gathering parser pass the label and content are reconstructed 681 # with the linking `text` (usually whitespace). 682 683 def link_to content, label = content, text = nil 684 raise 'enable notes extension' if 685 content.start_with? '^' and label.equal? content 686 687 if ref = @references[label] then 688 "{#{content}}[#{ref}]" 689 elsif label.equal? content then 690 "[#{content}]#{text}" 691 else 692 "[#{content}]#{text}[#{label}]" 693 end 694 end 695 696 ## 697 # Creates an RDoc::Markup::ListItem by parsing the `unparsed` content from 698 # the first parsing pass. 699 700 def list_item_from unparsed 701 parsed = inner_parse unparsed.join 702 RDoc::Markup::ListItem.new nil, *parsed 703 end 704 705 ## 706 # Stores `label` as a note and fills in previously unknown note references. 707 708 def note label 709 #foottext = "rdoc-label:foottext-#{label}:footmark-#{label}" 710 711 #ref.replace foottext if ref = @unlinked_notes.delete(label) 712 713 @notes[label] = foottext 714 715 #"{^1}[rdoc-label:footmark-#{label}:foottext-#{label}] " 716 end 717 718 ## 719 # Creates a new link for the footnote `reference` and adds the reference to 720 # the note order list for proper display at the end of the document. 721 722 def note_for ref 723 @note_order << ref 724 725 label = @note_order.length 726 727 "{*#{label}}[rdoc-label:foottext-#{label}:footmark-#{label}]" 728 end 729 730 ## 731 # The internal kpeg parse method 732 733 alias peg_parse parse # :nodoc: 734 735 ## 736 # Creates an RDoc::Markup::Paragraph from `parts` and including 737 # extension-specific behavior 738 739 def paragraph parts 740 parts = parts.map do |part| 741 if "\n" == part then 742 RDoc::Markup::HardBreak.new 743 else 744 part 745 end 746 end if break_on_newline? 747 748 RDoc::Markup::Paragraph.new(*parts) 749 end 750 751 ## 752 # Parses `markdown` into an RDoc::Document 753 754 def parse markdown 755 @references = {} 756 @unlinked_references = {} 757 758 markdown += "\n\n" 759 760 setup_parser markdown, @debug 761 peg_parse 'References' 762 763 if notes? then 764 @footnotes = {} 765 766 setup_parser markdown, @debug 767 peg_parse 'Notes' 768 769 # using note_order on the first pass would be a bug 770 @note_order = [] 771 end 772 773 setup_parser markdown, @debug 774 peg_parse 775 776 doc = result 777 778 if notes? and not @footnotes.empty? then 779 doc << RDoc::Markup::Rule.new(1) 780 781 @note_order.each_with_index do |ref, index| 782 label = index + 1 783 note = @footnotes[ref] 784 785 link = "{^#{label}}[rdoc-label:footmark-#{label}:foottext-#{label}] " 786 note.parts.unshift link 787 788 doc << note 789 end 790 end 791 792 doc.accept @formatter 793 794 doc 795 end 796 797 ## 798 # Stores `label` as a reference to `link` and fills in previously unknown 799 # link references. 800 801 def reference label, link 802 if ref = @unlinked_references.delete(label) then 803 ref.replace link 804 end 805 806 @references[label] = link 807 end 808 809 ## 810 # Wraps `text` in strong markup for rdoc inline formatting 811 812 def strong text 813 if text =~ /\A[a-z\d.\/-]+\z/i then 814 "*#{text}*" 815 else 816 "<b>#{text}</b>" 817 end 818 end 819 820 821 # :stopdoc: 822 def setup_foreign_grammar 823 @_grammar_literals = RDoc::Markdown::Literals.new(nil) 824 end 825 826 # root = Doc 827 def _root 828 _tmp = apply(:_Doc) 829 set_failed_rule :_root unless _tmp 830 return _tmp 831 end 832 833 # Doc = BOM? Block*:a { RDoc::Markup::Document.new(*a.compact) } 834 def _Doc 835 836 _save = self.pos 837 while true # sequence 838 _save1 = self.pos 839 _tmp = apply(:_BOM) 840 unless _tmp 841 _tmp = true 842 self.pos = _save1 843 end 844 unless _tmp 845 self.pos = _save 846 break 847 end 848 _ary = [] 849 while true 850 _tmp = apply(:_Block) 851 _ary << @result if _tmp 852 break unless _tmp 853 end 854 _tmp = true 855 @result = _ary 856 a = @result 857 unless _tmp 858 self.pos = _save 859 break 860 end 861 @result = begin; RDoc::Markup::Document.new(*a.compact) ; end 862 _tmp = true 863 unless _tmp 864 self.pos = _save 865 end 866 break 867 end # end sequence 868 869 set_failed_rule :_Doc unless _tmp 870 return _tmp 871 end 872 873 # Block = BlankLine* (BlockQuote | Verbatim | CodeFence | Note | Reference | HorizontalRule | Heading | OrderedList | BulletList | DefinitionList | HtmlBlock | StyleBlock | Para | Plain) 874 def _Block 875 876 _save = self.pos 877 while true # sequence 878 while true 879 _tmp = apply(:_BlankLine) 880 break unless _tmp 881 end 882 _tmp = true 883 unless _tmp 884 self.pos = _save 885 break 886 end 887 888 _save2 = self.pos 889 while true # choice 890 _tmp = apply(:_BlockQuote) 891 break if _tmp 892 self.pos = _save2 893 _tmp = apply(:_Verbatim) 894 break if _tmp 895 self.pos = _save2 896 _tmp = apply(:_CodeFence) 897 break if _tmp 898 self.pos = _save2 899 _tmp = apply(:_Note) 900 break if _tmp 901 self.pos = _save2 902 _tmp = apply(:_Reference) 903 break if _tmp 904 self.pos = _save2 905 _tmp = apply(:_HorizontalRule) 906 break if _tmp 907 self.pos = _save2 908 _tmp = apply(:_Heading) 909 break if _tmp 910 self.pos = _save2 911 _tmp = apply(:_OrderedList) 912 break if _tmp 913 self.pos = _save2 914 _tmp = apply(:_BulletList) 915 break if _tmp 916 self.pos = _save2 917 _tmp = apply(:_DefinitionList) 918 break if _tmp 919 self.pos = _save2 920 _tmp = apply(:_HtmlBlock) 921 break if _tmp 922 self.pos = _save2 923 _tmp = apply(:_StyleBlock) 924 break if _tmp 925 self.pos = _save2 926 _tmp = apply(:_Para) 927 break if _tmp 928 self.pos = _save2 929 _tmp = apply(:_Plain) 930 break if _tmp 931 self.pos = _save2 932 break 933 end # end choice 934 935 unless _tmp 936 self.pos = _save 937 end 938 break 939 end # end sequence 940 941 set_failed_rule :_Block unless _tmp 942 return _tmp 943 end 944 945 # Para = NonindentSpace Inlines:a BlankLine+ { paragraph a } 946 def _Para 947 948 _save = self.pos 949 while true # sequence 950 _tmp = apply(:_NonindentSpace) 951 unless _tmp 952 self.pos = _save 953 break 954 end 955 _tmp = apply(:_Inlines) 956 a = @result 957 unless _tmp 958 self.pos = _save 959 break 960 end 961 _save1 = self.pos 962 _tmp = apply(:_BlankLine) 963 if _tmp 964 while true 965 _tmp = apply(:_BlankLine) 966 break unless _tmp 967 end 968 _tmp = true 969 else 970 self.pos = _save1 971 end 972 unless _tmp 973 self.pos = _save 974 break 975 end 976 @result = begin; paragraph a ; end 977 _tmp = true 978 unless _tmp 979 self.pos = _save 980 end 981 break 982 end # end sequence 983 984 set_failed_rule :_Para unless _tmp 985 return _tmp 986 end 987 988 # Plain = Inlines:a { paragraph a } 989 def _Plain 990 991 _save = self.pos 992 while true # sequence 993 _tmp = apply(:_Inlines) 994 a = @result 995 unless _tmp 996 self.pos = _save 997 break 998 end 999 @result = begin; paragraph a ; end 1000 _tmp = true 1001 unless _tmp 1002 self.pos = _save 1003 end 1004 break 1005 end # end sequence 1006 1007 set_failed_rule :_Plain unless _tmp 1008 return _tmp 1009 end 1010 1011 # AtxInline = !Newline !(Sp? "#"* Sp Newline) Inline 1012 def _AtxInline 1013 1014 _save = self.pos 1015 while true # sequence 1016 _save1 = self.pos 1017 _tmp = apply(:_Newline) 1018 _tmp = _tmp ? nil : true 1019 self.pos = _save1 1020 unless _tmp 1021 self.pos = _save 1022 break 1023 end 1024 _save2 = self.pos 1025 1026 _save3 = self.pos 1027 while true # sequence 1028 _save4 = self.pos 1029 _tmp = apply(:_Sp) 1030 unless _tmp 1031 _tmp = true 1032 self.pos = _save4 1033 end 1034 unless _tmp 1035 self.pos = _save3 1036 break 1037 end 1038 while true 1039 _tmp = match_string("#") 1040 break unless _tmp 1041 end 1042 _tmp = true 1043 unless _tmp 1044 self.pos = _save3 1045 break 1046 end 1047 _tmp = apply(:_Sp) 1048 unless _tmp 1049 self.pos = _save3 1050 break 1051 end 1052 _tmp = apply(:_Newline) 1053 unless _tmp 1054 self.pos = _save3 1055 end 1056 break 1057 end # end sequence 1058 1059 _tmp = _tmp ? nil : true 1060 self.pos = _save2 1061 unless _tmp 1062 self.pos = _save 1063 break 1064 end 1065 _tmp = apply(:_Inline) 1066 unless _tmp 1067 self.pos = _save 1068 end 1069 break 1070 end # end sequence 1071 1072 set_failed_rule :_AtxInline unless _tmp 1073 return _tmp 1074 end 1075 1076 # AtxStart = < ("######" | "#####" | "####" | "###" | "##" | "#") > { text.length } 1077 def _AtxStart 1078 1079 _save = self.pos 1080 while true # sequence 1081 _text_start = self.pos 1082 1083 _save1 = self.pos 1084 while true # choice 1085 _tmp = match_string("######") 1086 break if _tmp 1087 self.pos = _save1 1088 _tmp = match_string("#####") 1089 break if _tmp 1090 self.pos = _save1 1091 _tmp = match_string("####") 1092 break if _tmp 1093 self.pos = _save1 1094 _tmp = match_string("###") 1095 break if _tmp 1096 self.pos = _save1 1097 _tmp = match_string("##") 1098 break if _tmp 1099 self.pos = _save1 1100 _tmp = match_string("#") 1101 break if _tmp 1102 self.pos = _save1 1103 break 1104 end # end choice 1105 1106 if _tmp 1107 text = get_text(_text_start) 1108 end 1109 unless _tmp 1110 self.pos = _save 1111 break 1112 end 1113 @result = begin; text.length ; end 1114 _tmp = true 1115 unless _tmp 1116 self.pos = _save 1117 end 1118 break 1119 end # end sequence 1120 1121 set_failed_rule :_AtxStart unless _tmp 1122 return _tmp 1123 end 1124 1125 # AtxHeading = AtxStart:s Sp? AtxInline+:a (Sp? "#"* Sp)? Newline { RDoc::Markup::Heading.new(s, a.join) } 1126 def _AtxHeading 1127 1128 _save = self.pos 1129 while true # sequence 1130 _tmp = apply(:_AtxStart) 1131 s = @result 1132 unless _tmp 1133 self.pos = _save 1134 break 1135 end 1136 _save1 = self.pos 1137 _tmp = apply(:_Sp) 1138 unless _tmp 1139 _tmp = true 1140 self.pos = _save1 1141 end 1142 unless _tmp 1143 self.pos = _save 1144 break 1145 end 1146 _save2 = self.pos 1147 _ary = [] 1148 _tmp = apply(:_AtxInline) 1149 if _tmp 1150 _ary << @result 1151 while true 1152 _tmp = apply(:_AtxInline) 1153 _ary << @result if _tmp 1154 break unless _tmp 1155 end 1156 _tmp = true 1157 @result = _ary 1158 else 1159 self.pos = _save2 1160 end 1161 a = @result 1162 unless _tmp 1163 self.pos = _save 1164 break 1165 end 1166 _save3 = self.pos 1167 1168 _save4 = self.pos 1169 while true # sequence 1170 _save5 = self.pos 1171 _tmp = apply(:_Sp) 1172 unless _tmp 1173 _tmp = true 1174 self.pos = _save5 1175 end 1176 unless _tmp 1177 self.pos = _save4 1178 break 1179 end 1180 while true 1181 _tmp = match_string("#") 1182 break unless _tmp 1183 end 1184 _tmp = true 1185 unless _tmp 1186 self.pos = _save4 1187 break 1188 end 1189 _tmp = apply(:_Sp) 1190 unless _tmp 1191 self.pos = _save4 1192 end 1193 break 1194 end # end sequence 1195 1196 unless _tmp 1197 _tmp = true 1198 self.pos = _save3 1199 end 1200 unless _tmp 1201 self.pos = _save 1202 break 1203 end 1204 _tmp = apply(:_Newline) 1205 unless _tmp 1206 self.pos = _save 1207 break 1208 end 1209 @result = begin; RDoc::Markup::Heading.new(s, a.join) ; end 1210 _tmp = true 1211 unless _tmp 1212 self.pos = _save 1213 end 1214 break 1215 end # end sequence 1216 1217 set_failed_rule :_AtxHeading unless _tmp 1218 return _tmp 1219 end 1220 1221 # SetextHeading = (SetextHeading1 | SetextHeading2) 1222 def _SetextHeading 1223 1224 _save = self.pos 1225 while true # choice 1226 _tmp = apply(:_SetextHeading1) 1227 break if _tmp 1228 self.pos = _save 1229 _tmp = apply(:_SetextHeading2) 1230 break if _tmp 1231 self.pos = _save 1232 break 1233 end # end choice 1234 1235 set_failed_rule :_SetextHeading unless _tmp 1236 return _tmp 1237 end 1238 1239 # SetextBottom1 = "===" "="* Newline 1240 def _SetextBottom1 1241 1242 _save = self.pos 1243 while true # sequence 1244 _tmp = match_string("===") 1245 unless _tmp 1246 self.pos = _save 1247 break 1248 end 1249 while true 1250 _tmp = match_string("=") 1251 break unless _tmp 1252 end 1253 _tmp = true 1254 unless _tmp 1255 self.pos = _save 1256 break 1257 end 1258 _tmp = apply(:_Newline) 1259 unless _tmp 1260 self.pos = _save 1261 end 1262 break 1263 end # end sequence 1264 1265 set_failed_rule :_SetextBottom1 unless _tmp 1266 return _tmp 1267 end 1268 1269 # SetextBottom2 = "---" "-"* Newline 1270 def _SetextBottom2 1271 1272 _save = self.pos 1273 while true # sequence 1274 _tmp = match_string("---") 1275 unless _tmp 1276 self.pos = _save 1277 break 1278 end 1279 while true 1280 _tmp = match_string("-") 1281 break unless _tmp 1282 end 1283 _tmp = true 1284 unless _tmp 1285 self.pos = _save 1286 break 1287 end 1288 _tmp = apply(:_Newline) 1289 unless _tmp 1290 self.pos = _save 1291 end 1292 break 1293 end # end sequence 1294 1295 set_failed_rule :_SetextBottom2 unless _tmp 1296 return _tmp 1297 end 1298 1299 # SetextHeading1 = &(RawLine SetextBottom1) StartList:a (!Endline Inline:b { a << b })+ Sp? Newline SetextBottom1 { RDoc::Markup::Heading.new(1, a.join) } 1300 def _SetextHeading1 1301 1302 _save = self.pos 1303 while true # sequence 1304 _save1 = self.pos 1305 1306 _save2 = self.pos 1307 while true # sequence 1308 _tmp = apply(:_RawLine) 1309 unless _tmp 1310 self.pos = _save2 1311 break 1312 end 1313 _tmp = apply(:_SetextBottom1) 1314 unless _tmp 1315 self.pos = _save2 1316 end 1317 break 1318 end # end sequence 1319 1320 self.pos = _save1 1321 unless _tmp 1322 self.pos = _save 1323 break 1324 end 1325 _tmp = apply(:_StartList) 1326 a = @result 1327 unless _tmp 1328 self.pos = _save 1329 break 1330 end 1331 _save3 = self.pos 1332 1333 _save4 = self.pos 1334 while true # sequence 1335 _save5 = self.pos 1336 _tmp = apply(:_Endline) 1337 _tmp = _tmp ? nil : true 1338 self.pos = _save5 1339 unless _tmp 1340 self.pos = _save4 1341 break 1342 end 1343 _tmp = apply(:_Inline) 1344 b = @result 1345 unless _tmp 1346 self.pos = _save4 1347 break 1348 end 1349 @result = begin; a << b ; end 1350 _tmp = true 1351 unless _tmp 1352 self.pos = _save4 1353 end 1354 break 1355 end # end sequence 1356 1357 if _tmp 1358 while true 1359 1360 _save6 = self.pos 1361 while true # sequence 1362 _save7 = self.pos 1363 _tmp = apply(:_Endline) 1364 _tmp = _tmp ? nil : true 1365 self.pos = _save7 1366 unless _tmp 1367 self.pos = _save6 1368 break 1369 end 1370 _tmp = apply(:_Inline) 1371 b = @result 1372 unless _tmp 1373 self.pos = _save6 1374 break 1375 end 1376 @result = begin; a << b ; end 1377 _tmp = true 1378 unless _tmp 1379 self.pos = _save6 1380 end 1381 break 1382 end # end sequence 1383 1384 break unless _tmp 1385 end 1386 _tmp = true 1387 else 1388 self.pos = _save3 1389 end 1390 unless _tmp 1391 self.pos = _save 1392 break 1393 end 1394 _save8 = self.pos 1395 _tmp = apply(:_Sp) 1396 unless _tmp 1397 _tmp = true 1398 self.pos = _save8 1399 end 1400 unless _tmp 1401 self.pos = _save 1402 break 1403 end 1404 _tmp = apply(:_Newline) 1405 unless _tmp 1406 self.pos = _save 1407 break 1408 end 1409 _tmp = apply(:_SetextBottom1) 1410 unless _tmp 1411 self.pos = _save 1412 break 1413 end 1414 @result = begin; RDoc::Markup::Heading.new(1, a.join) ; end 1415 _tmp = true 1416 unless _tmp 1417 self.pos = _save 1418 end 1419 break 1420 end # end sequence 1421 1422 set_failed_rule :_SetextHeading1 unless _tmp 1423 return _tmp 1424 end 1425 1426 # SetextHeading2 = &(RawLine SetextBottom2) StartList:a (!Endline Inline:b { a << b })+ Sp? Newline SetextBottom2 { RDoc::Markup::Heading.new(2, a.join) } 1427 def _SetextHeading2 1428 1429 _save = self.pos 1430 while true # sequence 1431 _save1 = self.pos 1432 1433 _save2 = self.pos 1434 while true # sequence 1435 _tmp = apply(:_RawLine) 1436 unless _tmp 1437 self.pos = _save2 1438 break 1439 end 1440 _tmp = apply(:_SetextBottom2) 1441 unless _tmp 1442 self.pos = _save2 1443 end 1444 break 1445 end # end sequence 1446 1447 self.pos = _save1 1448 unless _tmp 1449 self.pos = _save 1450 break 1451 end 1452 _tmp = apply(:_StartList) 1453 a = @result 1454 unless _tmp 1455 self.pos = _save 1456 break 1457 end 1458 _save3 = self.pos 1459 1460 _save4 = self.pos 1461 while true # sequence 1462 _save5 = self.pos 1463 _tmp = apply(:_Endline) 1464 _tmp = _tmp ? nil : true 1465 self.pos = _save5 1466 unless _tmp 1467 self.pos = _save4 1468 break 1469 end 1470 _tmp = apply(:_Inline) 1471 b = @result 1472 unless _tmp 1473 self.pos = _save4 1474 break 1475 end 1476 @result = begin; a << b ; end 1477 _tmp = true 1478 unless _tmp 1479 self.pos = _save4 1480 end 1481 break 1482 end # end sequence 1483 1484 if _tmp 1485 while true 1486 1487 _save6 = self.pos 1488 while true # sequence 1489 _save7 = self.pos 1490 _tmp = apply(:_Endline) 1491 _tmp = _tmp ? nil : true 1492 self.pos = _save7 1493 unless _tmp 1494 self.pos = _save6 1495 break 1496 end 1497 _tmp = apply(:_Inline) 1498 b = @result 1499 unless _tmp 1500 self.pos = _save6 1501 break 1502 end 1503 @result = begin; a << b ; end 1504 _tmp = true 1505 unless _tmp 1506 self.pos = _save6 1507 end 1508 break 1509 end # end sequence 1510 1511 break unless _tmp 1512 end 1513 _tmp = true 1514 else 1515 self.pos = _save3 1516 end 1517 unless _tmp 1518 self.pos = _save 1519 break 1520 end 1521 _save8 = self.pos 1522 _tmp = apply(:_Sp) 1523 unless _tmp 1524 _tmp = true 1525 self.pos = _save8 1526 end 1527 unless _tmp 1528 self.pos = _save 1529 break 1530 end 1531 _tmp = apply(:_Newline) 1532 unless _tmp 1533 self.pos = _save 1534 break 1535 end 1536 _tmp = apply(:_SetextBottom2) 1537 unless _tmp 1538 self.pos = _save 1539 break 1540 end 1541 @result = begin; RDoc::Markup::Heading.new(2, a.join) ; end 1542 _tmp = true 1543 unless _tmp 1544 self.pos = _save 1545 end 1546 break 1547 end # end sequence 1548 1549 set_failed_rule :_SetextHeading2 unless _tmp 1550 return _tmp 1551 end 1552 1553 # Heading = (SetextHeading | AtxHeading) 1554 def _Heading 1555 1556 _save = self.pos 1557 while true # choice 1558 _tmp = apply(:_SetextHeading) 1559 break if _tmp 1560 self.pos = _save 1561 _tmp = apply(:_AtxHeading) 1562 break if _tmp 1563 self.pos = _save 1564 break 1565 end # end choice 1566 1567 set_failed_rule :_Heading unless _tmp 1568 return _tmp 1569 end 1570 1571 # BlockQuote = BlockQuoteRaw:a { RDoc::Markup::BlockQuote.new(*a) } 1572 def _BlockQuote 1573 1574 _save = self.pos 1575 while true # sequence 1576 _tmp = apply(:_BlockQuoteRaw) 1577 a = @result 1578 unless _tmp 1579 self.pos = _save 1580 break 1581 end 1582 @result = begin; RDoc::Markup::BlockQuote.new(*a) ; end 1583 _tmp = true 1584 unless _tmp 1585 self.pos = _save 1586 end 1587 break 1588 end # end sequence 1589 1590 set_failed_rule :_BlockQuote unless _tmp 1591 return _tmp 1592 end 1593 1594 # BlockQuoteRaw = StartList:a (">" " "? Line:l { a << l } (!">" !BlankLine Line:c { a << c })* (BlankLine:n { a << n })*)+ { inner_parse a.join } 1595 def _BlockQuoteRaw 1596 1597 _save = self.pos 1598 while true # sequence 1599 _tmp = apply(:_StartList) 1600 a = @result 1601 unless _tmp 1602 self.pos = _save 1603 break 1604 end 1605 _save1 = self.pos 1606 1607 _save2 = self.pos 1608 while true # sequence 1609 _tmp = match_string(">") 1610 unless _tmp 1611 self.pos = _save2 1612 break 1613 end 1614 _save3 = self.pos 1615 _tmp = match_string(" ") 1616 unless _tmp 1617 _tmp = true 1618 self.pos = _save3 1619 end 1620 unless _tmp 1621 self.pos = _save2 1622 break 1623 end 1624 _tmp = apply(:_Line) 1625 l = @result 1626 unless _tmp 1627 self.pos = _save2 1628 break 1629 end 1630 @result = begin; a << l ; end 1631 _tmp = true 1632 unless _tmp 1633 self.pos = _save2 1634 break 1635 end 1636 while true 1637 1638 _save5 = self.pos 1639 while true # sequence 1640 _save6 = self.pos 1641 _tmp = match_string(">") 1642 _tmp = _tmp ? nil : true 1643 self.pos = _save6 1644 unless _tmp 1645 self.pos = _save5 1646 break 1647 end 1648 _save7 = self.pos 1649 _tmp = apply(:_BlankLine) 1650 _tmp = _tmp ? nil : true 1651 self.pos = _save7 1652 unless _tmp 1653 self.pos = _save5 1654 break 1655 end 1656 _tmp = apply(:_Line) 1657 c = @result 1658 unless _tmp 1659 self.pos = _save5 1660 break 1661 end 1662 @result = begin; a << c ; end 1663 _tmp = true 1664 unless _tmp 1665 self.pos = _save5 1666 end 1667 break 1668 end # end sequence 1669 1670 break unless _tmp 1671 end 1672 _tmp = true 1673 unless _tmp 1674 self.pos = _save2 1675 break 1676 end 1677 while true 1678 1679 _save9 = self.pos 1680 while true # sequence 1681 _tmp = apply(:_BlankLine) 1682 n = @result 1683 unless _tmp 1684 self.pos = _save9 1685 break 1686 end 1687 @result = begin; a << n ; end 1688 _tmp = true 1689 unless _tmp 1690 self.pos = _save9 1691 end 1692 break 1693 end # end sequence 1694 1695 break unless _tmp 1696 end 1697 _tmp = true 1698 unless _tmp 1699 self.pos = _save2 1700 end 1701 break 1702 end # end sequence 1703 1704 if _tmp 1705 while true 1706 1707 _save10 = self.pos 1708 while true # sequence 1709 _tmp = match_string(">") 1710 unless _tmp 1711 self.pos = _save10 1712 break 1713 end 1714 _save11 = self.pos 1715 _tmp = match_string(" ") 1716 unless _tmp 1717 _tmp = true 1718 self.pos = _save11 1719 end 1720 unless _tmp 1721 self.pos = _save10 1722 break 1723 end 1724 _tmp = apply(:_Line) 1725 l = @result 1726 unless _tmp 1727 self.pos = _save10 1728 break 1729 end 1730 @result = begin; a << l ; end 1731 _tmp = true 1732 unless _tmp 1733 self.pos = _save10 1734 break 1735 end 1736 while true 1737 1738 _save13 = self.pos 1739 while true # sequence 1740 _save14 = self.pos 1741 _tmp = match_string(">") 1742 _tmp = _tmp ? nil : true 1743 self.pos = _save14 1744 unless _tmp 1745 self.pos = _save13 1746 break 1747 end 1748 _save15 = self.pos 1749 _tmp = apply(:_BlankLine) 1750 _tmp = _tmp ? nil : true 1751 self.pos = _save15 1752 unless _tmp 1753 self.pos = _save13 1754 break 1755 end 1756 _tmp = apply(:_Line) 1757 c = @result 1758 unless _tmp 1759 self.pos = _save13 1760 break 1761 end 1762 @result = begin; a << c ; end 1763 _tmp = true 1764 unless _tmp 1765 self.pos = _save13 1766 end 1767 break 1768 end # end sequence 1769 1770 break unless _tmp 1771 end 1772 _tmp = true 1773 unless _tmp 1774 self.pos = _save10 1775 break 1776 end 1777 while true 1778 1779 _save17 = self.pos 1780 while true # sequence 1781 _tmp = apply(:_BlankLine) 1782 n = @result 1783 unless _tmp 1784 self.pos = _save17 1785 break 1786 end 1787 @result = begin; a << n ; end 1788 _tmp = true 1789 unless _tmp 1790 self.pos = _save17 1791 end 1792 break 1793 end # end sequence 1794 1795 break unless _tmp 1796 end 1797 _tmp = true 1798 unless _tmp 1799 self.pos = _save10 1800 end 1801 break 1802 end # end sequence 1803 1804 break unless _tmp 1805 end 1806 _tmp = true 1807 else 1808 self.pos = _save1 1809 end 1810 unless _tmp 1811 self.pos = _save 1812 break 1813 end 1814 @result = begin; inner_parse a.join ; end 1815 _tmp = true 1816 unless _tmp 1817 self.pos = _save 1818 end 1819 break 1820 end # end sequence 1821 1822 set_failed_rule :_BlockQuoteRaw unless _tmp 1823 return _tmp 1824 end 1825 1826 # NonblankIndentedLine = !BlankLine IndentedLine 1827 def _NonblankIndentedLine 1828 1829 _save = self.pos 1830 while true # sequence 1831 _save1 = self.pos 1832 _tmp = apply(:_BlankLine) 1833 _tmp = _tmp ? nil : true 1834 self.pos = _save1 1835 unless _tmp 1836 self.pos = _save 1837 break 1838 end 1839 _tmp = apply(:_IndentedLine) 1840 unless _tmp 1841 self.pos = _save 1842 end 1843 break 1844 end # end sequence 1845 1846 set_failed_rule :_NonblankIndentedLine unless _tmp 1847 return _tmp 1848 end 1849 1850 # VerbatimChunk = BlankLine*:a NonblankIndentedLine+:b { a.concat b } 1851 def _VerbatimChunk 1852 1853 _save = self.pos 1854 while true # sequence 1855 _ary = [] 1856 while true 1857 _tmp = apply(:_BlankLine) 1858 _ary << @result if _tmp 1859 break unless _tmp 1860 end 1861 _tmp = true 1862 @result = _ary 1863 a = @result 1864 unless _tmp 1865 self.pos = _save 1866 break 1867 end 1868 _save2 = self.pos 1869 _ary = [] 1870 _tmp = apply(:_NonblankIndentedLine) 1871 if _tmp 1872 _ary << @result 1873 while true 1874 _tmp = apply(:_NonblankIndentedLine) 1875 _ary << @result if _tmp 1876 break unless _tmp 1877 end 1878 _tmp = true 1879 @result = _ary 1880 else 1881 self.pos = _save2 1882 end 1883 b = @result 1884 unless _tmp 1885 self.pos = _save 1886 break 1887 end 1888 @result = begin; a.concat b ; end 1889 _tmp = true 1890 unless _tmp 1891 self.pos = _save 1892 end 1893 break 1894 end # end sequence 1895 1896 set_failed_rule :_VerbatimChunk unless _tmp 1897 return _tmp 1898 end 1899 1900 # Verbatim = VerbatimChunk+:a { RDoc::Markup::Verbatim.new(*a.flatten) } 1901 def _Verbatim 1902 1903 _save = self.pos 1904 while true # sequence 1905 _save1 = self.pos 1906 _ary = [] 1907 _tmp = apply(:_VerbatimChunk) 1908 if _tmp 1909 _ary << @result 1910 while true 1911 _tmp = apply(:_VerbatimChunk) 1912 _ary << @result if _tmp 1913 break unless _tmp 1914 end 1915 _tmp = true 1916 @result = _ary 1917 else 1918 self.pos = _save1 1919 end 1920 a = @result 1921 unless _tmp 1922 self.pos = _save 1923 break 1924 end 1925 @result = begin; RDoc::Markup::Verbatim.new(*a.flatten) ; end 1926 _tmp = true 1927 unless _tmp 1928 self.pos = _save 1929 end 1930 break 1931 end # end sequence 1932 1933 set_failed_rule :_Verbatim unless _tmp 1934 return _tmp 1935 end 1936 1937 # HorizontalRule = NonindentSpace ("*" Sp "*" Sp "*" (Sp "*")* | "-" Sp "-" Sp "-" (Sp "-")* | "_" Sp "_" Sp "_" (Sp "_")*) Sp Newline BlankLine+ { RDoc::Markup::Rule.new 1 } 1938 def _HorizontalRule 1939 1940 _save = self.pos 1941 while true # sequence 1942 _tmp = apply(:_NonindentSpace) 1943 unless _tmp 1944 self.pos = _save 1945 break 1946 end 1947 1948 _save1 = self.pos 1949 while true # choice 1950 1951 _save2 = self.pos 1952 while true # sequence 1953 _tmp = match_string("*") 1954 unless _tmp 1955 self.pos = _save2 1956 break 1957 end 1958 _tmp = apply(:_Sp) 1959 unless _tmp 1960 self.pos = _save2 1961 break 1962 end 1963 _tmp = match_string("*") 1964 unless _tmp 1965 self.pos = _save2 1966 break 1967 end 1968 _tmp = apply(:_Sp) 1969 unless _tmp 1970 self.pos = _save2 1971 break 1972 end 1973 _tmp = match_string("*") 1974 unless _tmp 1975 self.pos = _save2 1976 break 1977 end 1978 while true 1979 1980 _save4 = self.pos 1981 while true # sequence 1982 _tmp = apply(:_Sp) 1983 unless _tmp 1984 self.pos = _save4 1985 break 1986 end 1987 _tmp = match_string("*") 1988 unless _tmp 1989 self.pos = _save4 1990 end 1991 break 1992 end # end sequence 1993 1994 break unless _tmp 1995 end 1996 _tmp = true 1997 unless _tmp 1998 self.pos = _save2 1999 end 2000 break 2001 end # end sequence 2002 2003 break if _tmp 2004 self.pos = _save1 2005 2006 _save5 = self.pos 2007 while true # sequence 2008 _tmp = match_string("-") 2009 unless _tmp 2010 self.pos = _save5 2011 break 2012 end 2013 _tmp = apply(:_Sp) 2014 unless _tmp 2015 self.pos = _save5 2016 break 2017 end 2018 _tmp = match_string("-") 2019 unless _tmp 2020 self.pos = _save5 2021 break 2022 end 2023 _tmp = apply(:_Sp) 2024 unless _tmp 2025 self.pos = _save5 2026 break 2027 end 2028 _tmp = match_string("-") 2029 unless _tmp 2030 self.pos = _save5 2031 break 2032 end 2033 while true 2034 2035 _save7 = self.pos 2036 while true # sequence 2037 _tmp = apply(:_Sp) 2038 unless _tmp 2039 self.pos = _save7 2040 break 2041 end 2042 _tmp = match_string("-") 2043 unless _tmp 2044 self.pos = _save7 2045 end 2046 break 2047 end # end sequence 2048 2049 break unless _tmp 2050 end 2051 _tmp = true 2052 unless _tmp 2053 self.pos = _save5 2054 end 2055 break 2056 end # end sequence 2057 2058 break if _tmp 2059 self.pos = _save1 2060 2061 _save8 = self.pos 2062 while true # sequence 2063 _tmp = match_string("_") 2064 unless _tmp 2065 self.pos = _save8 2066 break 2067 end 2068 _tmp = apply(:_Sp) 2069 unless _tmp 2070 self.pos = _save8 2071 break 2072 end 2073 _tmp = match_string("_") 2074 unless _tmp 2075 self.pos = _save8 2076 break 2077 end 2078 _tmp = apply(:_Sp) 2079 unless _tmp 2080 self.pos = _save8 2081 break 2082 end 2083 _tmp = match_string("_") 2084 unless _tmp 2085 self.pos = _save8 2086 break 2087 end 2088 while true 2089 2090 _save10 = self.pos 2091 while true # sequence 2092 _tmp = apply(:_Sp) 2093 unless _tmp 2094 self.pos = _save10 2095 break 2096 end 2097 _tmp = match_string("_") 2098 unless _tmp 2099 self.pos = _save10 2100 end 2101 break 2102 end # end sequence 2103 2104 break unless _tmp 2105 end 2106 _tmp = true 2107 unless _tmp 2108 self.pos = _save8 2109 end 2110 break 2111 end # end sequence 2112 2113 break if _tmp 2114 self.pos = _save1 2115 break 2116 end # end choice 2117 2118 unless _tmp 2119 self.pos = _save 2120 break 2121 end 2122 _tmp = apply(:_Sp) 2123 unless _tmp 2124 self.pos = _save 2125 break 2126 end 2127 _tmp = apply(:_Newline) 2128 unless _tmp 2129 self.pos = _save 2130 break 2131 end 2132 _save11 = self.pos 2133 _tmp = apply(:_BlankLine) 2134 if _tmp 2135 while true 2136 _tmp = apply(:_BlankLine) 2137 break unless _tmp 2138 end 2139 _tmp = true 2140 else 2141 self.pos = _save11 2142 end 2143 unless _tmp 2144 self.pos = _save 2145 break 2146 end 2147 @result = begin; RDoc::Markup::Rule.new 1 ; end 2148 _tmp = true 2149 unless _tmp 2150 self.pos = _save 2151 end 2152 break 2153 end # end sequence 2154 2155 set_failed_rule :_HorizontalRule unless _tmp 2156 return _tmp 2157 end 2158 2159 # Bullet = !HorizontalRule NonindentSpace ("+" | "*" | "-") Spacechar+ 2160 def _Bullet 2161 2162 _save = self.pos 2163 while true # sequence 2164 _save1 = self.pos 2165 _tmp = apply(:_HorizontalRule) 2166 _tmp = _tmp ? nil : true 2167 self.pos = _save1 2168 unless _tmp 2169 self.pos = _save 2170 break 2171 end 2172 _tmp = apply(:_NonindentSpace) 2173 unless _tmp 2174 self.pos = _save 2175 break 2176 end 2177 2178 _save2 = self.pos 2179 while true # choice 2180 _tmp = match_string("+") 2181 break if _tmp 2182 self.pos = _save2 2183 _tmp = match_string("*") 2184 break if _tmp 2185 self.pos = _save2 2186 _tmp = match_string("-") 2187 break if _tmp 2188 self.pos = _save2 2189 break 2190 end # end choice 2191 2192 unless _tmp 2193 self.pos = _save 2194 break 2195 end 2196 _save3 = self.pos 2197 _tmp = apply(:_Spacechar) 2198 if _tmp 2199 while true 2200 _tmp = apply(:_Spacechar) 2201 break unless _tmp 2202 end 2203 _tmp = true 2204 else 2205 self.pos = _save3 2206 end 2207 unless _tmp 2208 self.pos = _save 2209 end 2210 break 2211 end # end sequence 2212 2213 set_failed_rule :_Bullet unless _tmp 2214 return _tmp 2215 end 2216 2217 # BulletList = &Bullet (ListTight | ListLoose):a { RDoc::Markup::List.new(:BULLET, *a) } 2218 def _BulletList 2219 2220 _save = self.pos 2221 while true # sequence 2222 _save1 = self.pos 2223 _tmp = apply(:_Bullet) 2224 self.pos = _save1 2225 unless _tmp 2226 self.pos = _save 2227 break 2228 end 2229 2230 _save2 = self.pos 2231 while true # choice 2232 _tmp = apply(:_ListTight) 2233 break if _tmp 2234 self.pos = _save2 2235 _tmp = apply(:_ListLoose) 2236 break if _tmp 2237 self.pos = _save2 2238 break 2239 end # end choice 2240 2241 a = @result 2242 unless _tmp 2243 self.pos = _save 2244 break 2245 end 2246 @result = begin; RDoc::Markup::List.new(:BULLET, *a) ; end 2247 _tmp = true 2248 unless _tmp 2249 self.pos = _save 2250 end 2251 break 2252 end # end sequence 2253 2254 set_failed_rule :_BulletList unless _tmp 2255 return _tmp 2256 end 2257 2258 # ListTight = ListItemTight+:a BlankLine* !(Bullet | Enumerator) { a } 2259 def _ListTight 2260 2261 _save = self.pos 2262 while true # sequence 2263 _save1 = self.pos 2264 _ary = [] 2265 _tmp = apply(:_ListItemTight) 2266 if _tmp 2267 _ary << @result 2268 while true 2269 _tmp = apply(:_ListItemTight) 2270 _ary << @result if _tmp 2271 break unless _tmp 2272 end 2273 _tmp = true 2274 @result = _ary 2275 else 2276 self.pos = _save1 2277 end 2278 a = @result 2279 unless _tmp 2280 self.pos = _save 2281 break 2282 end 2283 while true 2284 _tmp = apply(:_BlankLine) 2285 break unless _tmp 2286 end 2287 _tmp = true 2288 unless _tmp 2289 self.pos = _save 2290 break 2291 end 2292 _save3 = self.pos 2293 2294 _save4 = self.pos 2295 while true # choice 2296 _tmp = apply(:_Bullet) 2297 break if _tmp 2298 self.pos = _save4 2299 _tmp = apply(:_Enumerator) 2300 break if _tmp 2301 self.pos = _save4 2302 break 2303 end # end choice 2304 2305 _tmp = _tmp ? nil : true 2306 self.pos = _save3 2307 unless _tmp 2308 self.pos = _save 2309 break 2310 end 2311 @result = begin; a ; end 2312 _tmp = true 2313 unless _tmp 2314 self.pos = _save 2315 end 2316 break 2317 end # end sequence 2318 2319 set_failed_rule :_ListTight unless _tmp 2320 return _tmp 2321 end 2322 2323 # ListLoose = StartList:a (ListItem:b BlankLine* { a << b })+ { a } 2324 def _ListLoose 2325 2326 _save = self.pos 2327 while true # sequence 2328 _tmp = apply(:_StartList) 2329 a = @result 2330 unless _tmp 2331 self.pos = _save 2332 break 2333 end 2334 _save1 = self.pos 2335 2336 _save2 = self.pos 2337 while true # sequence 2338 _tmp = apply(:_ListItem) 2339 b = @result 2340 unless _tmp 2341 self.pos = _save2 2342 break 2343 end 2344 while true 2345 _tmp = apply(:_BlankLine) 2346 break unless _tmp 2347 end 2348 _tmp = true 2349 unless _tmp 2350 self.pos = _save2 2351 break 2352 end 2353 @result = begin; a << b ; end 2354 _tmp = true 2355 unless _tmp 2356 self.pos = _save2 2357 end 2358 break 2359 end # end sequence 2360 2361 if _tmp 2362 while true 2363 2364 _save4 = self.pos 2365 while true # sequence 2366 _tmp = apply(:_ListItem) 2367 b = @result 2368 unless _tmp 2369 self.pos = _save4 2370 break 2371 end 2372 while true 2373 _tmp = apply(:_BlankLine) 2374 break unless _tmp 2375 end 2376 _tmp = true 2377 unless _tmp 2378 self.pos = _save4 2379 break 2380 end 2381 @result = begin; a << b ; end 2382 _tmp = true 2383 unless _tmp 2384 self.pos = _save4 2385 end 2386 break 2387 end # end sequence 2388 2389 break unless _tmp 2390 end 2391 _tmp = true 2392 else 2393 self.pos = _save1 2394 end 2395 unless _tmp 2396 self.pos = _save 2397 break 2398 end 2399 @result = begin; a ; end 2400 _tmp = true 2401 unless _tmp 2402 self.pos = _save 2403 end 2404 break 2405 end # end sequence 2406 2407 set_failed_rule :_ListLoose unless _tmp 2408 return _tmp 2409 end 2410 2411 # ListItem = (Bullet | Enumerator) StartList:a ListBlock:b { a << b } (ListContinuationBlock:c { a.push(*c) })* { list_item_from a } 2412 def _ListItem 2413 2414 _save = self.pos 2415 while true # sequence 2416 2417 _save1 = self.pos 2418 while true # choice 2419 _tmp = apply(:_Bullet) 2420 break if _tmp 2421 self.pos = _save1 2422 _tmp = apply(:_Enumerator) 2423 break if _tmp 2424 self.pos = _save1 2425 break 2426 end # end choice 2427 2428 unless _tmp 2429 self.pos = _save 2430 break 2431 end 2432 _tmp = apply(:_StartList) 2433 a = @result 2434 unless _tmp 2435 self.pos = _save 2436 break 2437 end 2438 _tmp = apply(:_ListBlock) 2439 b = @result 2440 unless _tmp 2441 self.pos = _save 2442 break 2443 end 2444 @result = begin; a << b ; end 2445 _tmp = true 2446 unless _tmp 2447 self.pos = _save 2448 break 2449 end 2450 while true 2451 2452 _save3 = self.pos 2453 while true # sequence 2454 _tmp = apply(:_ListContinuationBlock) 2455 c = @result 2456 unless _tmp 2457 self.pos = _save3 2458 break 2459 end 2460 @result = begin; a.push(*c) ; end 2461 _tmp = true 2462 unless _tmp 2463 self.pos = _save3 2464 end 2465 break 2466 end # end sequence 2467 2468 break unless _tmp 2469 end 2470 _tmp = true 2471 unless _tmp 2472 self.pos = _save 2473 break 2474 end 2475 @result = begin; list_item_from a ; end 2476 _tmp = true 2477 unless _tmp 2478 self.pos = _save 2479 end 2480 break 2481 end # end sequence 2482 2483 set_failed_rule :_ListItem unless _tmp 2484 return _tmp 2485 end 2486 2487 # ListItemTight = (Bullet | Enumerator) ListBlock:a (!BlankLine ListContinuationBlock:b { a.push(*b) })* !ListContinuationBlock { list_item_from a } 2488 def _ListItemTight 2489 2490 _save = self.pos 2491 while true # sequence 2492 2493 _save1 = self.pos 2494 while true # choice 2495 _tmp = apply(:_Bullet) 2496 break if _tmp 2497 self.pos = _save1 2498 _tmp = apply(:_Enumerator) 2499 break if _tmp 2500 self.pos = _save1 2501 break 2502 end # end choice 2503 2504 unless _tmp 2505 self.pos = _save 2506 break 2507 end 2508 _tmp = apply(:_ListBlock) 2509 a = @result 2510 unless _tmp 2511 self.pos = _save 2512 break 2513 end 2514 while true 2515 2516 _save3 = self.pos 2517 while true # sequence 2518 _save4 = self.pos 2519 _tmp = apply(:_BlankLine) 2520 _tmp = _tmp ? nil : true 2521 self.pos = _save4 2522 unless _tmp 2523 self.pos = _save3 2524 break 2525 end 2526 _tmp = apply(:_ListContinuationBlock) 2527 b = @result 2528 unless _tmp 2529 self.pos = _save3 2530 break 2531 end 2532 @result = begin; a.push(*b) ; end 2533 _tmp = true 2534 unless _tmp 2535 self.pos = _save3 2536 end 2537 break 2538 end # end sequence 2539 2540 break unless _tmp 2541 end 2542 _tmp = true 2543 unless _tmp 2544 self.pos = _save 2545 break 2546 end 2547 _save5 = self.pos 2548 _tmp = apply(:_ListContinuationBlock) 2549 _tmp = _tmp ? nil : true 2550 self.pos = _save5 2551 unless _tmp 2552 self.pos = _save 2553 break 2554 end 2555 @result = begin; list_item_from a ; end 2556 _tmp = true 2557 unless _tmp 2558 self.pos = _save 2559 end 2560 break 2561 end # end sequence 2562 2563 set_failed_rule :_ListItemTight unless _tmp 2564 return _tmp 2565 end 2566 2567 # ListBlock = !BlankLine Line:a ListBlockLine*:c { [a, *c] } 2568 def _ListBlock 2569 2570 _save = self.pos 2571 while true # sequence 2572 _save1 = self.pos 2573 _tmp = apply(:_BlankLine) 2574 _tmp = _tmp ? nil : true 2575 self.pos = _save1 2576 unless _tmp 2577 self.pos = _save 2578 break 2579 end 2580 _tmp = apply(:_Line) 2581 a = @result 2582 unless _tmp 2583 self.pos = _save 2584 break 2585 end 2586 _ary = [] 2587 while true 2588 _tmp = apply(:_ListBlockLine) 2589 _ary << @result if _tmp 2590 break unless _tmp 2591 end 2592 _tmp = true 2593 @result = _ary 2594 c = @result 2595 unless _tmp 2596 self.pos = _save 2597 break 2598 end 2599 @result = begin; [a, *c] ; end 2600 _tmp = true 2601 unless _tmp 2602 self.pos = _save 2603 end 2604 break 2605 end # end sequence 2606 2607 set_failed_rule :_ListBlock unless _tmp 2608 return _tmp 2609 end 2610 2611 # ListContinuationBlock = StartList:a BlankLine* { a << "\n" } (Indent ListBlock:b { a.concat b })+ { a } 2612 def _ListContinuationBlock 2613 2614 _save = self.pos 2615 while true # sequence 2616 _tmp = apply(:_StartList) 2617 a = @result 2618 unless _tmp 2619 self.pos = _save 2620 break 2621 end 2622 while true 2623 _tmp = apply(:_BlankLine) 2624 break unless _tmp 2625 end 2626 _tmp = true 2627 unless _tmp 2628 self.pos = _save 2629 break 2630 end 2631 @result = begin; a << "\n" ; end 2632 _tmp = true 2633 unless _tmp 2634 self.pos = _save 2635 break 2636 end 2637 _save2 = self.pos 2638 2639 _save3 = self.pos 2640 while true # sequence 2641 _tmp = apply(:_Indent) 2642 unless _tmp 2643 self.pos = _save3 2644 break 2645 end 2646 _tmp = apply(:_ListBlock) 2647 b = @result 2648 unless _tmp 2649 self.pos = _save3 2650 break 2651 end 2652 @result = begin; a.concat b ; end 2653 _tmp = true 2654 unless _tmp 2655 self.pos = _save3 2656 end 2657 break 2658 end # end sequence 2659 2660 if _tmp 2661 while true 2662 2663 _save4 = self.pos 2664 while true # sequence 2665 _tmp = apply(:_Indent) 2666 unless _tmp 2667 self.pos = _save4 2668 break 2669 end 2670 _tmp = apply(:_ListBlock) 2671 b = @result 2672 unless _tmp 2673 self.pos = _save4 2674 break 2675 end 2676 @result = begin; a.concat b ; end 2677 _tmp = true 2678 unless _tmp 2679 self.pos = _save4 2680 end 2681 break 2682 end # end sequence 2683 2684 break unless _tmp 2685 end 2686 _tmp = true 2687 else 2688 self.pos = _save2 2689 end 2690 unless _tmp 2691 self.pos = _save 2692 break 2693 end 2694 @result = begin; a ; end 2695 _tmp = true 2696 unless _tmp 2697 self.pos = _save 2698 end 2699 break 2700 end # end sequence 2701 2702 set_failed_rule :_ListContinuationBlock unless _tmp 2703 return _tmp 2704 end 2705 2706 # Enumerator = NonindentSpace [0-9]+ "." Spacechar+ 2707 def _Enumerator 2708 2709 _save = self.pos 2710 while true # sequence 2711 _tmp = apply(:_NonindentSpace) 2712 unless _tmp 2713 self.pos = _save 2714 break 2715 end 2716 _save1 = self.pos 2717 _save2 = self.pos 2718 _tmp = get_byte 2719 if _tmp 2720 unless _tmp >= 48 and _tmp <= 57 2721 self.pos = _save2 2722 _tmp = nil 2723 end 2724 end 2725 if _tmp 2726 while true 2727 _save3 = self.pos 2728 _tmp = get_byte 2729 if _tmp 2730 unless _tmp >= 48 and _tmp <= 57 2731 self.pos = _save3 2732 _tmp = nil 2733 end 2734 end 2735 break unless _tmp 2736 end 2737 _tmp = true 2738 else 2739 self.pos = _save1 2740 end 2741 unless _tmp 2742 self.pos = _save 2743 break 2744 end 2745 _tmp = match_string(".") 2746 unless _tmp 2747 self.pos = _save 2748 break 2749 end 2750 _save4 = self.pos 2751 _tmp = apply(:_Spacechar) 2752 if _tmp 2753 while true 2754 _tmp = apply(:_Spacechar) 2755 break unless _tmp 2756 end 2757 _tmp = true 2758 else 2759 self.pos = _save4 2760 end 2761 unless _tmp 2762 self.pos = _save 2763 end 2764 break 2765 end # end sequence 2766 2767 set_failed_rule :_Enumerator unless _tmp 2768 return _tmp 2769 end 2770 2771 # OrderedList = &Enumerator (ListTight | ListLoose):a { RDoc::Markup::List.new(:NUMBER, *a) } 2772 def _OrderedList 2773 2774 _save = self.pos 2775 while true # sequence 2776 _save1 = self.pos 2777 _tmp = apply(:_Enumerator) 2778 self.pos = _save1 2779 unless _tmp 2780 self.pos = _save 2781 break 2782 end 2783 2784 _save2 = self.pos 2785 while true # choice 2786 _tmp = apply(:_ListTight) 2787 break if _tmp 2788 self.pos = _save2 2789 _tmp = apply(:_ListLoose) 2790 break if _tmp 2791 self.pos = _save2 2792 break 2793 end # end choice 2794 2795 a = @result 2796 unless _tmp 2797 self.pos = _save 2798 break 2799 end 2800 @result = begin; RDoc::Markup::List.new(:NUMBER, *a) ; end 2801 _tmp = true 2802 unless _tmp 2803 self.pos = _save 2804 end 2805 break 2806 end # end sequence 2807 2808 set_failed_rule :_OrderedList unless _tmp 2809 return _tmp 2810 end 2811 2812 # ListBlockLine = !BlankLine !(Indent? (Bullet | Enumerator)) !HorizontalRule OptionallyIndentedLine 2813 def _ListBlockLine 2814 2815 _save = self.pos 2816 while true # sequence 2817 _save1 = self.pos 2818 _tmp = apply(:_BlankLine) 2819 _tmp = _tmp ? nil : true 2820 self.pos = _save1 2821 unless _tmp 2822 self.pos = _save 2823 break 2824 end 2825 _save2 = self.pos 2826 2827 _save3 = self.pos 2828 while true # sequence 2829 _save4 = self.pos 2830 _tmp = apply(:_Indent) 2831 unless _tmp 2832 _tmp = true 2833 self.pos = _save4 2834 end 2835 unless _tmp 2836 self.pos = _save3 2837 break 2838 end 2839 2840 _save5 = self.pos 2841 while true # choice 2842 _tmp = apply(:_Bullet) 2843 break if _tmp 2844 self.pos = _save5 2845 _tmp = apply(:_Enumerator) 2846 break if _tmp 2847 self.pos = _save5 2848 break 2849 end # end choice 2850 2851 unless _tmp 2852 self.pos = _save3 2853 end 2854 break 2855 end # end sequence 2856 2857 _tmp = _tmp ? nil : true 2858 self.pos = _save2 2859 unless _tmp 2860 self.pos = _save 2861 break 2862 end 2863 _save6 = self.pos 2864 _tmp = apply(:_HorizontalRule) 2865 _tmp = _tmp ? nil : true 2866 self.pos = _save6 2867 unless _tmp 2868 self.pos = _save 2869 break 2870 end 2871 _tmp = apply(:_OptionallyIndentedLine) 2872 unless _tmp 2873 self.pos = _save 2874 end 2875 break 2876 end # end sequence 2877 2878 set_failed_rule :_ListBlockLine unless _tmp 2879 return _tmp 2880 end 2881 2882 # HtmlBlockOpenAddress = "<" Spnl ("address" | "ADDRESS") Spnl HtmlAttribute* ">" 2883 def _HtmlBlockOpenAddress 2884 2885 _save = self.pos 2886 while true # sequence 2887 _tmp = match_string("<") 2888 unless _tmp 2889 self.pos = _save 2890 break 2891 end 2892 _tmp = apply(:_Spnl) 2893 unless _tmp 2894 self.pos = _save 2895 break 2896 end 2897 2898 _save1 = self.pos 2899 while true # choice 2900 _tmp = match_string("address") 2901 break if _tmp 2902 self.pos = _save1 2903 _tmp = match_string("ADDRESS") 2904 break if _tmp 2905 self.pos = _save1 2906 break 2907 end # end choice 2908 2909 unless _tmp 2910 self.pos = _save 2911 break 2912 end 2913 _tmp = apply(:_Spnl) 2914 unless _tmp 2915 self.pos = _save 2916 break 2917 end 2918 while true 2919 _tmp = apply(:_HtmlAttribute) 2920 break unless _tmp 2921 end 2922 _tmp = true 2923 unless _tmp 2924 self.pos = _save 2925 break 2926 end 2927 _tmp = match_string(">") 2928 unless _tmp 2929 self.pos = _save 2930 end 2931 break 2932 end # end sequence 2933 2934 set_failed_rule :_HtmlBlockOpenAddress unless _tmp 2935 return _tmp 2936 end 2937 2938 # HtmlBlockCloseAddress = "<" Spnl "/" ("address" | "ADDRESS") Spnl ">" 2939 def _HtmlBlockCloseAddress 2940 2941 _save = self.pos 2942 while true # sequence 2943 _tmp = match_string("<") 2944 unless _tmp 2945 self.pos = _save 2946 break 2947 end 2948 _tmp = apply(:_Spnl) 2949 unless _tmp 2950 self.pos = _save 2951 break 2952 end 2953 _tmp = match_string("/") 2954 unless _tmp 2955 self.pos = _save 2956 break 2957 end 2958 2959 _save1 = self.pos 2960 while true # choice 2961 _tmp = match_string("address") 2962 break if _tmp 2963 self.pos = _save1 2964 _tmp = match_string("ADDRESS") 2965 break if _tmp 2966 self.pos = _save1 2967 break 2968 end # end choice 2969 2970 unless _tmp 2971 self.pos = _save 2972 break 2973 end 2974 _tmp = apply(:_Spnl) 2975 unless _tmp 2976 self.pos = _save 2977 break 2978 end 2979 _tmp = match_string(">") 2980 unless _tmp 2981 self.pos = _save 2982 end 2983 break 2984 end # end sequence 2985 2986 set_failed_rule :_HtmlBlockCloseAddress unless _tmp 2987 return _tmp 2988 end 2989 2990 # HtmlBlockAddress = HtmlBlockOpenAddress (HtmlBlockAddress | !HtmlBlockCloseAddress .)* HtmlBlockCloseAddress 2991 def _HtmlBlockAddress 2992 2993 _save = self.pos 2994 while true # sequence 2995 _tmp = apply(:_HtmlBlockOpenAddress) 2996 unless _tmp 2997 self.pos = _save 2998 break 2999 end 3000 while true 3001 3002 _save2 = self.pos 3003 while true # choice 3004 _tmp = apply(:_HtmlBlockAddress) 3005 break if _tmp 3006 self.pos = _save2 3007 3008 _save3 = self.pos 3009 while true # sequence 3010 _save4 = self.pos 3011 _tmp = apply(:_HtmlBlockCloseAddress) 3012 _tmp = _tmp ? nil : true 3013 self.pos = _save4 3014 unless _tmp 3015 self.pos = _save3 3016 break 3017 end 3018 _tmp = get_byte 3019 unless _tmp 3020 self.pos = _save3 3021 end 3022 break 3023 end # end sequence 3024 3025 break if _tmp 3026 self.pos = _save2 3027 break 3028 end # end choice 3029 3030 break unless _tmp 3031 end 3032 _tmp = true 3033 unless _tmp 3034 self.pos = _save 3035 break 3036 end 3037 _tmp = apply(:_HtmlBlockCloseAddress) 3038 unless _tmp 3039 self.pos = _save 3040 end 3041 break 3042 end # end sequence 3043 3044 set_failed_rule :_HtmlBlockAddress unless _tmp 3045 return _tmp 3046 end 3047 3048 # HtmlBlockOpenBlockquote = "<" Spnl ("blockquote" | "BLOCKQUOTE") Spnl HtmlAttribute* ">" 3049 def _HtmlBlockOpenBlockquote 3050 3051 _save = self.pos 3052 while true # sequence 3053 _tmp = match_string("<") 3054 unless _tmp 3055 self.pos = _save 3056 break 3057 end 3058 _tmp = apply(:_Spnl) 3059 unless _tmp 3060 self.pos = _save 3061 break 3062 end 3063 3064 _save1 = self.pos 3065 while true # choice 3066 _tmp = match_string("blockquote") 3067 break if _tmp 3068 self.pos = _save1 3069 _tmp = match_string("BLOCKQUOTE") 3070 break if _tmp 3071 self.pos = _save1 3072 break 3073 end # end choice 3074 3075 unless _tmp 3076 self.pos = _save 3077 break 3078 end 3079 _tmp = apply(:_Spnl) 3080 unless _tmp 3081 self.pos = _save 3082 break 3083 end 3084 while true 3085 _tmp = apply(:_HtmlAttribute) 3086 break unless _tmp 3087 end 3088 _tmp = true 3089 unless _tmp 3090 self.pos = _save 3091 break 3092 end 3093 _tmp = match_string(">") 3094 unless _tmp 3095 self.pos = _save 3096 end 3097 break 3098 end # end sequence 3099 3100 set_failed_rule :_HtmlBlockOpenBlockquote unless _tmp 3101 return _tmp 3102 end 3103 3104 # HtmlBlockCloseBlockquote = "<" Spnl "/" ("blockquote" | "BLOCKQUOTE") Spnl ">" 3105 def _HtmlBlockCloseBlockquote 3106 3107 _save = self.pos 3108 while true # sequence 3109 _tmp = match_string("<") 3110 unless _tmp 3111 self.pos = _save 3112 break 3113 end 3114 _tmp = apply(:_Spnl) 3115 unless _tmp 3116 self.pos = _save 3117 break 3118 end 3119 _tmp = match_string("/") 3120 unless _tmp 3121 self.pos = _save 3122 break 3123 end 3124 3125 _save1 = self.pos 3126 while true # choice 3127 _tmp = match_string("blockquote") 3128 break if _tmp 3129 self.pos = _save1 3130 _tmp = match_string("BLOCKQUOTE") 3131 break if _tmp 3132 self.pos = _save1 3133 break 3134 end # end choice 3135 3136 unless _tmp 3137 self.pos = _save 3138 break 3139 end 3140 _tmp = apply(:_Spnl) 3141 unless _tmp 3142 self.pos = _save 3143 break 3144 end 3145 _tmp = match_string(">") 3146 unless _tmp 3147 self.pos = _save 3148 end 3149 break 3150 end # end sequence 3151 3152 set_failed_rule :_HtmlBlockCloseBlockquote unless _tmp 3153 return _tmp 3154 end 3155 3156 # HtmlBlockBlockquote = HtmlBlockOpenBlockquote (HtmlBlockBlockquote | !HtmlBlockCloseBlockquote .)* HtmlBlockCloseBlockquote 3157 def _HtmlBlockBlockquote 3158 3159 _save = self.pos 3160 while true # sequence 3161 _tmp = apply(:_HtmlBlockOpenBlockquote) 3162 unless _tmp 3163 self.pos = _save 3164 break 3165 end 3166 while true 3167 3168 _save2 = self.pos 3169 while true # choice 3170 _tmp = apply(:_HtmlBlockBlockquote) 3171 break if _tmp 3172 self.pos = _save2 3173 3174 _save3 = self.pos 3175 while true # sequence 3176 _save4 = self.pos 3177 _tmp = apply(:_HtmlBlockCloseBlockquote) 3178 _tmp = _tmp ? nil : true 3179 self.pos = _save4 3180 unless _tmp 3181 self.pos = _save3 3182 break 3183 end 3184 _tmp = get_byte 3185 unless _tmp 3186 self.pos = _save3 3187 end 3188 break 3189 end # end sequence 3190 3191 break if _tmp 3192 self.pos = _save2 3193 break 3194 end # end choice 3195 3196 break unless _tmp 3197 end 3198 _tmp = true 3199 unless _tmp 3200 self.pos = _save 3201 break 3202 end 3203 _tmp = apply(:_HtmlBlockCloseBlockquote) 3204 unless _tmp 3205 self.pos = _save 3206 end 3207 break 3208 end # end sequence 3209 3210 set_failed_rule :_HtmlBlockBlockquote unless _tmp 3211 return _tmp 3212 end 3213 3214 # HtmlBlockOpenCenter = "<" Spnl ("center" | "CENTER") Spnl HtmlAttribute* ">" 3215 def _HtmlBlockOpenCenter 3216 3217 _save = self.pos 3218 while true # sequence 3219 _tmp = match_string("<") 3220 unless _tmp 3221 self.pos = _save 3222 break 3223 end 3224 _tmp = apply(:_Spnl) 3225 unless _tmp 3226 self.pos = _save 3227 break 3228 end 3229 3230 _save1 = self.pos 3231 while true # choice 3232 _tmp = match_string("center") 3233 break if _tmp 3234 self.pos = _save1 3235 _tmp = match_string("CENTER") 3236 break if _tmp 3237 self.pos = _save1 3238 break 3239 end # end choice 3240 3241 unless _tmp 3242 self.pos = _save 3243 break 3244 end 3245 _tmp = apply(:_Spnl) 3246 unless _tmp 3247 self.pos = _save 3248 break 3249 end 3250 while true 3251 _tmp = apply(:_HtmlAttribute) 3252 break unless _tmp 3253 end 3254 _tmp = true 3255 unless _tmp 3256 self.pos = _save 3257 break 3258 end 3259 _tmp = match_string(">") 3260 unless _tmp 3261 self.pos = _save 3262 end 3263 break 3264 end # end sequence 3265 3266 set_failed_rule :_HtmlBlockOpenCenter unless _tmp 3267 return _tmp 3268 end 3269 3270 # HtmlBlockCloseCenter = "<" Spnl "/" ("center" | "CENTER") Spnl ">" 3271 def _HtmlBlockCloseCenter 3272 3273 _save = self.pos 3274 while true # sequence 3275 _tmp = match_string("<") 3276 unless _tmp 3277 self.pos = _save 3278 break 3279 end 3280 _tmp = apply(:_Spnl) 3281 unless _tmp 3282 self.pos = _save 3283 break 3284 end 3285 _tmp = match_string("/") 3286 unless _tmp 3287 self.pos = _save 3288 break 3289 end 3290 3291 _save1 = self.pos 3292 while true # choice 3293 _tmp = match_string("center") 3294 break if _tmp 3295 self.pos = _save1 3296 _tmp = match_string("CENTER") 3297 break if _tmp 3298 self.pos = _save1 3299 break 3300 end # end choice 3301 3302 unless _tmp 3303 self.pos = _save 3304 break 3305 end 3306 _tmp = apply(:_Spnl) 3307 unless _tmp 3308 self.pos = _save 3309 break 3310 end 3311 _tmp = match_string(">") 3312 unless _tmp 3313 self.pos = _save 3314 end 3315 break 3316 end # end sequence 3317 3318 set_failed_rule :_HtmlBlockCloseCenter unless _tmp 3319 return _tmp 3320 end 3321 3322 # HtmlBlockCenter = HtmlBlockOpenCenter (HtmlBlockCenter | !HtmlBlockCloseCenter .)* HtmlBlockCloseCenter 3323 def _HtmlBlockCenter 3324 3325 _save = self.pos 3326 while true # sequence 3327 _tmp = apply(:_HtmlBlockOpenCenter) 3328 unless _tmp 3329 self.pos = _save 3330 break 3331 end 3332 while true 3333 3334 _save2 = self.pos 3335 while true # choice 3336 _tmp = apply(:_HtmlBlockCenter) 3337 break if _tmp 3338 self.pos = _save2 3339 3340 _save3 = self.pos 3341 while true # sequence 3342 _save4 = self.pos 3343 _tmp = apply(:_HtmlBlockCloseCenter) 3344 _tmp = _tmp ? nil : true 3345 self.pos = _save4 3346 unless _tmp 3347 self.pos = _save3 3348 break 3349 end 3350 _tmp = get_byte 3351 unless _tmp 3352 self.pos = _save3 3353 end 3354 break 3355 end # end sequence 3356 3357 break if _tmp 3358 self.pos = _save2 3359 break 3360 end # end choice 3361 3362 break unless _tmp 3363 end 3364 _tmp = true 3365 unless _tmp 3366 self.pos = _save 3367 break 3368 end 3369 _tmp = apply(:_HtmlBlockCloseCenter) 3370 unless _tmp 3371 self.pos = _save 3372 end 3373 break 3374 end # end sequence 3375 3376 set_failed_rule :_HtmlBlockCenter unless _tmp 3377 return _tmp 3378 end 3379 3380 # HtmlBlockOpenDir = "<" Spnl ("dir" | "DIR") Spnl HtmlAttribute* ">" 3381 def _HtmlBlockOpenDir 3382 3383 _save = self.pos 3384 while true # sequence 3385 _tmp = match_string("<") 3386 unless _tmp 3387 self.pos = _save 3388 break 3389 end 3390 _tmp = apply(:_Spnl) 3391 unless _tmp 3392 self.pos = _save 3393 break 3394 end 3395 3396 _save1 = self.pos 3397 while true # choice 3398 _tmp = match_string("dir") 3399 break if _tmp 3400 self.pos = _save1 3401 _tmp = match_string("DIR") 3402 break if _tmp 3403 self.pos = _save1 3404 break 3405 end # end choice 3406 3407 unless _tmp 3408 self.pos = _save 3409 break 3410 end 3411 _tmp = apply(:_Spnl) 3412 unless _tmp 3413 self.pos = _save 3414 break 3415 end 3416 while true 3417 _tmp = apply(:_HtmlAttribute) 3418 break unless _tmp 3419 end 3420 _tmp = true 3421 unless _tmp 3422 self.pos = _save 3423 break 3424 end 3425 _tmp = match_string(">") 3426 unless _tmp 3427 self.pos = _save 3428 end 3429 break 3430 end # end sequence 3431 3432 set_failed_rule :_HtmlBlockOpenDir unless _tmp 3433 return _tmp 3434 end 3435 3436 # HtmlBlockCloseDir = "<" Spnl "/" ("dir" | "DIR") Spnl ">" 3437 def _HtmlBlockCloseDir 3438 3439 _save = self.pos 3440 while true # sequence 3441 _tmp = match_string("<") 3442 unless _tmp 3443 self.pos = _save 3444 break 3445 end 3446 _tmp = apply(:_Spnl) 3447 unless _tmp 3448 self.pos = _save 3449 break 3450 end 3451 _tmp = match_string("/") 3452 unless _tmp 3453 self.pos = _save 3454 break 3455 end 3456 3457 _save1 = self.pos 3458 while true # choice 3459 _tmp = match_string("dir") 3460 break if _tmp 3461 self.pos = _save1 3462 _tmp = match_string("DIR") 3463 break if _tmp 3464 self.pos = _save1 3465 break 3466 end # end choice 3467 3468 unless _tmp 3469 self.pos = _save 3470 break 3471 end 3472 _tmp = apply(:_Spnl) 3473 unless _tmp 3474 self.pos = _save 3475 break 3476 end 3477 _tmp = match_string(">") 3478 unless _tmp 3479 self.pos = _save 3480 end 3481 break 3482 end # end sequence 3483 3484 set_failed_rule :_HtmlBlockCloseDir unless _tmp 3485 return _tmp 3486 end 3487 3488 # HtmlBlockDir = HtmlBlockOpenDir (HtmlBlockDir | !HtmlBlockCloseDir .)* HtmlBlockCloseDir 3489 def _HtmlBlockDir 3490 3491 _save = self.pos 3492 while true # sequence 3493 _tmp = apply(:_HtmlBlockOpenDir) 3494 unless _tmp 3495 self.pos = _save 3496 break 3497 end 3498 while true 3499 3500 _save2 = self.pos 3501 while true # choice 3502 _tmp = apply(:_HtmlBlockDir) 3503 break if _tmp 3504 self.pos = _save2 3505 3506 _save3 = self.pos 3507 while true # sequence 3508 _save4 = self.pos 3509 _tmp = apply(:_HtmlBlockCloseDir) 3510 _tmp = _tmp ? nil : true 3511 self.pos = _save4 3512 unless _tmp 3513 self.pos = _save3 3514 break 3515 end 3516 _tmp = get_byte 3517 unless _tmp 3518 self.pos = _save3 3519 end 3520 break 3521 end # end sequence 3522 3523 break if _tmp 3524 self.pos = _save2 3525 break 3526 end # end choice 3527 3528 break unless _tmp 3529 end 3530 _tmp = true 3531 unless _tmp 3532 self.pos = _save 3533 break 3534 end 3535 _tmp = apply(:_HtmlBlockCloseDir) 3536 unless _tmp 3537 self.pos = _save 3538 end 3539 break 3540 end # end sequence 3541 3542 set_failed_rule :_HtmlBlockDir unless _tmp 3543 return _tmp 3544 end 3545 3546 # HtmlBlockOpenDiv = "<" Spnl ("div" | "DIV") Spnl HtmlAttribute* ">" 3547 def _HtmlBlockOpenDiv 3548 3549 _save = self.pos 3550 while true # sequence 3551 _tmp = match_string("<") 3552 unless _tmp 3553 self.pos = _save 3554 break 3555 end 3556 _tmp = apply(:_Spnl) 3557 unless _tmp 3558 self.pos = _save 3559 break 3560 end 3561 3562 _save1 = self.pos 3563 while true # choice 3564 _tmp = match_string("div") 3565 break if _tmp 3566 self.pos = _save1 3567 _tmp = match_string("DIV") 3568 break if _tmp 3569 self.pos = _save1 3570 break 3571 end # end choice 3572 3573 unless _tmp 3574 self.pos = _save 3575 break 3576 end 3577 _tmp = apply(:_Spnl) 3578 unless _tmp 3579 self.pos = _save 3580 break 3581 end 3582 while true 3583 _tmp = apply(:_HtmlAttribute) 3584 break unless _tmp 3585 end 3586 _tmp = true 3587 unless _tmp 3588 self.pos = _save 3589 break 3590 end 3591 _tmp = match_string(">") 3592 unless _tmp 3593 self.pos = _save 3594 end 3595 break 3596 end # end sequence 3597 3598 set_failed_rule :_HtmlBlockOpenDiv unless _tmp 3599 return _tmp 3600 end 3601 3602 # HtmlBlockCloseDiv = "<" Spnl "/" ("div" | "DIV") Spnl ">" 3603 def _HtmlBlockCloseDiv 3604 3605 _save = self.pos 3606 while true # sequence 3607 _tmp = match_string("<") 3608 unless _tmp 3609 self.pos = _save 3610 break 3611 end 3612 _tmp = apply(:_Spnl) 3613 unless _tmp 3614 self.pos = _save 3615 break 3616 end 3617 _tmp = match_string("/") 3618 unless _tmp 3619 self.pos = _save 3620 break 3621 end 3622 3623 _save1 = self.pos 3624 while true # choice 3625 _tmp = match_string("div") 3626 break if _tmp 3627 self.pos = _save1 3628 _tmp = match_string("DIV") 3629 break if _tmp 3630 self.pos = _save1 3631 break 3632 end # end choice 3633 3634 unless _tmp 3635 self.pos = _save 3636 break 3637 end 3638 _tmp = apply(:_Spnl) 3639 unless _tmp 3640 self.pos = _save 3641 break 3642 end 3643 _tmp = match_string(">") 3644 unless _tmp 3645 self.pos = _save 3646 end 3647 break 3648 end # end sequence 3649 3650 set_failed_rule :_HtmlBlockCloseDiv unless _tmp 3651 return _tmp 3652 end 3653 3654 # HtmlBlockDiv = HtmlBlockOpenDiv (HtmlBlockDiv | !HtmlBlockCloseDiv .)* HtmlBlockCloseDiv 3655 def _HtmlBlockDiv 3656 3657 _save = self.pos 3658 while true # sequence 3659 _tmp = apply(:_HtmlBlockOpenDiv) 3660 unless _tmp 3661 self.pos = _save 3662 break 3663 end 3664 while true 3665 3666 _save2 = self.pos 3667 while true # choice 3668 _tmp = apply(:_HtmlBlockDiv) 3669 break if _tmp 3670 self.pos = _save2 3671 3672 _save3 = self.pos 3673 while true # sequence 3674 _save4 = self.pos 3675 _tmp = apply(:_HtmlBlockCloseDiv) 3676 _tmp = _tmp ? nil : true 3677 self.pos = _save4 3678 unless _tmp 3679 self.pos = _save3 3680 break 3681 end 3682 _tmp = get_byte 3683 unless _tmp 3684 self.pos = _save3 3685 end 3686 break 3687 end # end sequence 3688 3689 break if _tmp 3690 self.pos = _save2 3691 break 3692 end # end choice 3693 3694 break unless _tmp 3695 end 3696 _tmp = true 3697 unless _tmp 3698 self.pos = _save 3699 break 3700 end 3701 _tmp = apply(:_HtmlBlockCloseDiv) 3702 unless _tmp 3703 self.pos = _save 3704 end 3705 break 3706 end # end sequence 3707 3708 set_failed_rule :_HtmlBlockDiv unless _tmp 3709 return _tmp 3710 end 3711 3712 # HtmlBlockOpenDl = "<" Spnl ("dl" | "DL") Spnl HtmlAttribute* ">" 3713 def _HtmlBlockOpenDl 3714 3715 _save = self.pos 3716 while true # sequence 3717 _tmp = match_string("<") 3718 unless _tmp 3719 self.pos = _save 3720 break 3721 end 3722 _tmp = apply(:_Spnl) 3723 unless _tmp 3724 self.pos = _save 3725 break 3726 end 3727 3728 _save1 = self.pos 3729 while true # choice 3730 _tmp = match_string("dl") 3731 break if _tmp 3732 self.pos = _save1 3733 _tmp = match_string("DL") 3734 break if _tmp 3735 self.pos = _save1 3736 break 3737 end # end choice 3738 3739 unless _tmp 3740 self.pos = _save 3741 break 3742 end 3743 _tmp = apply(:_Spnl) 3744 unless _tmp 3745 self.pos = _save 3746 break 3747 end 3748 while true 3749 _tmp = apply(:_HtmlAttribute) 3750 break unless _tmp 3751 end 3752 _tmp = true 3753 unless _tmp 3754 self.pos = _save 3755 break 3756 end 3757 _tmp = match_string(">") 3758 unless _tmp 3759 self.pos = _save 3760 end 3761 break 3762 end # end sequence 3763 3764 set_failed_rule :_HtmlBlockOpenDl unless _tmp 3765 return _tmp 3766 end 3767 3768 # HtmlBlockCloseDl = "<" Spnl "/" ("dl" | "DL") Spnl ">" 3769 def _HtmlBlockCloseDl 3770 3771 _save = self.pos 3772 while true # sequence 3773 _tmp = match_string("<") 3774 unless _tmp 3775 self.pos = _save 3776 break 3777 end 3778 _tmp = apply(:_Spnl) 3779 unless _tmp 3780 self.pos = _save 3781 break 3782 end 3783 _tmp = match_string("/") 3784 unless _tmp 3785 self.pos = _save 3786 break 3787 end 3788 3789 _save1 = self.pos 3790 while true # choice 3791 _tmp = match_string("dl") 3792 break if _tmp 3793 self.pos = _save1 3794 _tmp = match_string("DL") 3795 break if _tmp 3796 self.pos = _save1 3797 break 3798 end # end choice 3799 3800 unless _tmp 3801 self.pos = _save 3802 break 3803 end 3804 _tmp = apply(:_Spnl) 3805 unless _tmp 3806 self.pos = _save 3807 break 3808 end 3809 _tmp = match_string(">") 3810 unless _tmp 3811 self.pos = _save 3812 end 3813 break 3814 end # end sequence 3815 3816 set_failed_rule :_HtmlBlockCloseDl unless _tmp 3817 return _tmp 3818 end 3819 3820 # HtmlBlockDl = HtmlBlockOpenDl (HtmlBlockDl | !HtmlBlockCloseDl .)* HtmlBlockCloseDl 3821 def _HtmlBlockDl 3822 3823 _save = self.pos 3824 while true # sequence 3825 _tmp = apply(:_HtmlBlockOpenDl) 3826 unless _tmp 3827 self.pos = _save 3828 break 3829 end 3830 while true 3831 3832 _save2 = self.pos 3833 while true # choice 3834 _tmp = apply(:_HtmlBlockDl) 3835 break if _tmp 3836 self.pos = _save2 3837 3838 _save3 = self.pos 3839 while true # sequence 3840 _save4 = self.pos 3841 _tmp = apply(:_HtmlBlockCloseDl) 3842 _tmp = _tmp ? nil : true 3843 self.pos = _save4 3844 unless _tmp 3845 self.pos = _save3 3846 break 3847 end 3848 _tmp = get_byte 3849 unless _tmp 3850 self.pos = _save3 3851 end 3852 break 3853 end # end sequence 3854 3855 break if _tmp 3856 self.pos = _save2 3857 break 3858 end # end choice 3859 3860 break unless _tmp 3861 end 3862 _tmp = true 3863 unless _tmp 3864 self.pos = _save 3865 break 3866 end 3867 _tmp = apply(:_HtmlBlockCloseDl) 3868 unless _tmp 3869 self.pos = _save 3870 end 3871 break 3872 end # end sequence 3873 3874 set_failed_rule :_HtmlBlockDl unless _tmp 3875 return _tmp 3876 end 3877 3878 # HtmlBlockOpenFieldset = "<" Spnl ("fieldset" | "FIELDSET") Spnl HtmlAttribute* ">" 3879 def _HtmlBlockOpenFieldset 3880 3881 _save = self.pos 3882 while true # sequence 3883 _tmp = match_string("<") 3884 unless _tmp 3885 self.pos = _save 3886 break 3887 end 3888 _tmp = apply(:_Spnl) 3889 unless _tmp 3890 self.pos = _save 3891 break 3892 end 3893 3894 _save1 = self.pos 3895 while true # choice 3896 _tmp = match_string("fieldset") 3897 break if _tmp 3898 self.pos = _save1 3899 _tmp = match_string("FIELDSET") 3900 break if _tmp 3901 self.pos = _save1 3902 break 3903 end # end choice 3904 3905 unless _tmp 3906 self.pos = _save 3907 break 3908 end 3909 _tmp = apply(:_Spnl) 3910 unless _tmp 3911 self.pos = _save 3912 break 3913 end 3914 while true 3915 _tmp = apply(:_HtmlAttribute) 3916 break unless _tmp 3917 end 3918 _tmp = true 3919 unless _tmp 3920 self.pos = _save 3921 break 3922 end 3923 _tmp = match_string(">") 3924 unless _tmp 3925 self.pos = _save 3926 end 3927 break 3928 end # end sequence 3929 3930 set_failed_rule :_HtmlBlockOpenFieldset unless _tmp 3931 return _tmp 3932 end 3933 3934 # HtmlBlockCloseFieldset = "<" Spnl "/" ("fieldset" | "FIELDSET") Spnl ">" 3935 def _HtmlBlockCloseFieldset 3936 3937 _save = self.pos 3938 while true # sequence 3939 _tmp = match_string("<") 3940 unless _tmp 3941 self.pos = _save 3942 break 3943 end 3944 _tmp = apply(:_Spnl) 3945 unless _tmp 3946 self.pos = _save 3947 break 3948 end 3949 _tmp = match_string("/") 3950 unless _tmp 3951 self.pos = _save 3952 break 3953 end 3954 3955 _save1 = self.pos 3956 while true # choice 3957 _tmp = match_string("fieldset") 3958 break if _tmp 3959 self.pos = _save1 3960 _tmp = match_string("FIELDSET") 3961 break if _tmp 3962 self.pos = _save1 3963 break 3964 end # end choice 3965 3966 unless _tmp 3967 self.pos = _save 3968 break 3969 end 3970 _tmp = apply(:_Spnl) 3971 unless _tmp 3972 self.pos = _save 3973 break 3974 end 3975 _tmp = match_string(">") 3976 unless _tmp 3977 self.pos = _save 3978 end 3979 break 3980 end # end sequence 3981 3982 set_failed_rule :_HtmlBlockCloseFieldset unless _tmp 3983 return _tmp 3984 end 3985 3986 # HtmlBlockFieldset = HtmlBlockOpenFieldset (HtmlBlockFieldset | !HtmlBlockCloseFieldset .)* HtmlBlockCloseFieldset 3987 def _HtmlBlockFieldset 3988 3989 _save = self.pos 3990 while true # sequence 3991 _tmp = apply(:_HtmlBlockOpenFieldset) 3992 unless _tmp 3993 self.pos = _save 3994 break 3995 end 3996 while true 3997 3998 _save2 = self.pos 3999 while true # choice 4000 _tmp = apply(:_HtmlBlockFieldset) 4001 break if _tmp 4002 self.pos = _save2 4003 4004 _save3 = self.pos 4005 while true # sequence 4006 _save4 = self.pos 4007 _tmp = apply(:_HtmlBlockCloseFieldset) 4008 _tmp = _tmp ? nil : true 4009 self.pos = _save4 4010 unless _tmp 4011 self.pos = _save3 4012 break 4013 end 4014 _tmp = get_byte 4015 unless _tmp 4016 self.pos = _save3 4017 end 4018 break 4019 end # end sequence 4020 4021 break if _tmp 4022 self.pos = _save2 4023 break 4024 end # end choice 4025 4026 break unless _tmp 4027 end 4028 _tmp = true 4029 unless _tmp 4030 self.pos = _save 4031 break 4032 end 4033 _tmp = apply(:_HtmlBlockCloseFieldset) 4034 unless _tmp 4035 self.pos = _save 4036 end 4037 break 4038 end # end sequence 4039 4040 set_failed_rule :_HtmlBlockFieldset unless _tmp 4041 return _tmp 4042 end 4043 4044 # HtmlBlockOpenForm = "<" Spnl ("form" | "FORM") Spnl HtmlAttribute* ">" 4045 def _HtmlBlockOpenForm 4046 4047 _save = self.pos 4048 while true # sequence 4049 _tmp = match_string("<") 4050 unless _tmp 4051 self.pos = _save 4052 break 4053 end 4054 _tmp = apply(:_Spnl) 4055 unless _tmp 4056 self.pos = _save 4057 break 4058 end 4059 4060 _save1 = self.pos 4061 while true # choice 4062 _tmp = match_string("form") 4063 break if _tmp 4064 self.pos = _save1 4065 _tmp = match_string("FORM") 4066 break if _tmp 4067 self.pos = _save1 4068 break 4069 end # end choice 4070 4071 unless _tmp 4072 self.pos = _save 4073 break 4074 end 4075 _tmp = apply(:_Spnl) 4076 unless _tmp 4077 self.pos = _save 4078 break 4079 end 4080 while true 4081 _tmp = apply(:_HtmlAttribute) 4082 break unless _tmp 4083 end 4084 _tmp = true 4085 unless _tmp 4086 self.pos = _save 4087 break 4088 end 4089 _tmp = match_string(">") 4090 unless _tmp 4091 self.pos = _save 4092 end 4093 break 4094 end # end sequence 4095 4096 set_failed_rule :_HtmlBlockOpenForm unless _tmp 4097 return _tmp 4098 end 4099 4100 # HtmlBlockCloseForm = "<" Spnl "/" ("form" | "FORM") Spnl ">" 4101 def _HtmlBlockCloseForm 4102 4103 _save = self.pos 4104 while true # sequence 4105 _tmp = match_string("<") 4106 unless _tmp 4107 self.pos = _save 4108 break 4109 end 4110 _tmp = apply(:_Spnl) 4111 unless _tmp 4112 self.pos = _save 4113 break 4114 end 4115 _tmp = match_string("/") 4116 unless _tmp 4117 self.pos = _save 4118 break 4119 end 4120 4121 _save1 = self.pos 4122 while true # choice 4123 _tmp = match_string("form") 4124 break if _tmp 4125 self.pos = _save1 4126 _tmp = match_string("FORM") 4127 break if _tmp 4128 self.pos = _save1 4129 break 4130 end # end choice 4131 4132 unless _tmp 4133 self.pos = _save 4134 break 4135 end 4136 _tmp = apply(:_Spnl) 4137 unless _tmp 4138 self.pos = _save 4139 break 4140 end 4141 _tmp = match_string(">") 4142 unless _tmp 4143 self.pos = _save 4144 end 4145 break 4146 end # end sequence 4147 4148 set_failed_rule :_HtmlBlockCloseForm unless _tmp 4149 return _tmp 4150 end 4151 4152 # HtmlBlockForm = HtmlBlockOpenForm (HtmlBlockForm | !HtmlBlockCloseForm .)* HtmlBlockCloseForm 4153 def _HtmlBlockForm 4154 4155 _save = self.pos 4156 while true # sequence 4157 _tmp = apply(:_HtmlBlockOpenForm) 4158 unless _tmp 4159 self.pos = _save 4160 break 4161 end 4162 while true 4163 4164 _save2 = self.pos 4165 while true # choice 4166 _tmp = apply(:_HtmlBlockForm) 4167 break if _tmp 4168 self.pos = _save2 4169 4170 _save3 = self.pos 4171 while true # sequence 4172 _save4 = self.pos 4173 _tmp = apply(:_HtmlBlockCloseForm) 4174 _tmp = _tmp ? nil : true 4175 self.pos = _save4 4176 unless _tmp 4177 self.pos = _save3 4178 break 4179 end 4180 _tmp = get_byte 4181 unless _tmp 4182 self.pos = _save3 4183 end 4184 break 4185 end # end sequence 4186 4187 break if _tmp 4188 self.pos = _save2 4189 break 4190 end # end choice 4191 4192 break unless _tmp 4193 end 4194 _tmp = true 4195 unless _tmp 4196 self.pos = _save 4197 break 4198 end 4199 _tmp = apply(:_HtmlBlockCloseForm) 4200 unless _tmp 4201 self.pos = _save 4202 end 4203 break 4204 end # end sequence 4205 4206 set_failed_rule :_HtmlBlockForm unless _tmp 4207 return _tmp 4208 end 4209 4210 # HtmlBlockOpenH1 = "<" Spnl ("h1" | "H1") Spnl HtmlAttribute* ">" 4211 def _HtmlBlockOpenH1 4212 4213 _save = self.pos 4214 while true # sequence 4215 _tmp = match_string("<") 4216 unless _tmp 4217 self.pos = _save 4218 break 4219 end 4220 _tmp = apply(:_Spnl) 4221 unless _tmp 4222 self.pos = _save 4223 break 4224 end 4225 4226 _save1 = self.pos 4227 while true # choice 4228 _tmp = match_string("h1") 4229 break if _tmp 4230 self.pos = _save1 4231 _tmp = match_string("H1") 4232 break if _tmp 4233 self.pos = _save1 4234 break 4235 end # end choice 4236 4237 unless _tmp 4238 self.pos = _save 4239 break 4240 end 4241 _tmp = apply(:_Spnl) 4242 unless _tmp 4243 self.pos = _save 4244 break 4245 end 4246 while true 4247 _tmp = apply(:_HtmlAttribute) 4248 break unless _tmp 4249 end 4250 _tmp = true 4251 unless _tmp 4252 self.pos = _save 4253 break 4254 end 4255 _tmp = match_string(">") 4256 unless _tmp 4257 self.pos = _save 4258 end 4259 break 4260 end # end sequence 4261 4262 set_failed_rule :_HtmlBlockOpenH1 unless _tmp 4263 return _tmp 4264 end 4265 4266 # HtmlBlockCloseH1 = "<" Spnl "/" ("h1" | "H1") Spnl ">" 4267 def _HtmlBlockCloseH1 4268 4269 _save = self.pos 4270 while true # sequence 4271 _tmp = match_string("<") 4272 unless _tmp 4273 self.pos = _save 4274 break 4275 end 4276 _tmp = apply(:_Spnl) 4277 unless _tmp 4278 self.pos = _save 4279 break 4280 end 4281 _tmp = match_string("/") 4282 unless _tmp 4283 self.pos = _save 4284 break 4285 end 4286 4287 _save1 = self.pos 4288 while true # choice 4289 _tmp = match_string("h1") 4290 break if _tmp 4291 self.pos = _save1 4292 _tmp = match_string("H1") 4293 break if _tmp 4294 self.pos = _save1 4295 break 4296 end # end choice 4297 4298 unless _tmp 4299 self.pos = _save 4300 break 4301 end 4302 _tmp = apply(:_Spnl) 4303 unless _tmp 4304 self.pos = _save 4305 break 4306 end 4307 _tmp = match_string(">") 4308 unless _tmp 4309 self.pos = _save 4310 end 4311 break 4312 end # end sequence 4313 4314 set_failed_rule :_HtmlBlockCloseH1 unless _tmp 4315 return _tmp 4316 end 4317 4318 # HtmlBlockH1 = HtmlBlockOpenH1 (HtmlBlockH1 | !HtmlBlockCloseH1 .)* HtmlBlockCloseH1 4319 def _HtmlBlockH1 4320 4321 _save = self.pos 4322 while true # sequence 4323 _tmp = apply(:_HtmlBlockOpenH1) 4324 unless _tmp 4325 self.pos = _save 4326 break 4327 end 4328 while true 4329 4330 _save2 = self.pos 4331 while true # choice 4332 _tmp = apply(:_HtmlBlockH1) 4333 break if _tmp 4334 self.pos = _save2 4335 4336 _save3 = self.pos 4337 while true # sequence 4338 _save4 = self.pos 4339 _tmp = apply(:_HtmlBlockCloseH1) 4340 _tmp = _tmp ? nil : true 4341 self.pos = _save4 4342 unless _tmp 4343 self.pos = _save3 4344 break 4345 end 4346 _tmp = get_byte 4347 unless _tmp 4348 self.pos = _save3 4349 end 4350 break 4351 end # end sequence 4352 4353 break if _tmp 4354 self.pos = _save2 4355 break 4356 end # end choice 4357 4358 break unless _tmp 4359 end 4360 _tmp = true 4361 unless _tmp 4362 self.pos = _save 4363 break 4364 end 4365 _tmp = apply(:_HtmlBlockCloseH1) 4366 unless _tmp 4367 self.pos = _save 4368 end 4369 break 4370 end # end sequence 4371 4372 set_failed_rule :_HtmlBlockH1 unless _tmp 4373 return _tmp 4374 end 4375 4376 # HtmlBlockOpenH2 = "<" Spnl ("h2" | "H2") Spnl HtmlAttribute* ">" 4377 def _HtmlBlockOpenH2 4378 4379 _save = self.pos 4380 while true # sequence 4381 _tmp = match_string("<") 4382 unless _tmp 4383 self.pos = _save 4384 break 4385 end 4386 _tmp = apply(:_Spnl) 4387 unless _tmp 4388 self.pos = _save 4389 break 4390 end 4391 4392 _save1 = self.pos 4393 while true # choice 4394 _tmp = match_string("h2") 4395 break if _tmp 4396 self.pos = _save1 4397 _tmp = match_string("H2") 4398 break if _tmp 4399 self.pos = _save1 4400 break 4401 end # end choice 4402 4403 unless _tmp 4404 self.pos = _save 4405 break 4406 end 4407 _tmp = apply(:_Spnl) 4408 unless _tmp 4409 self.pos = _save 4410 break 4411 end 4412 while true 4413 _tmp = apply(:_HtmlAttribute) 4414 break unless _tmp 4415 end 4416 _tmp = true 4417 unless _tmp 4418 self.pos = _save 4419 break 4420 end 4421 _tmp = match_string(">") 4422 unless _tmp 4423 self.pos = _save 4424 end 4425 break 4426 end # end sequence 4427 4428 set_failed_rule :_HtmlBlockOpenH2 unless _tmp 4429 return _tmp 4430 end 4431 4432 # HtmlBlockCloseH2 = "<" Spnl "/" ("h2" | "H2") Spnl ">" 4433 def _HtmlBlockCloseH2 4434 4435 _save = self.pos 4436 while true # sequence 4437 _tmp = match_string("<") 4438 unless _tmp 4439 self.pos = _save 4440 break 4441 end 4442 _tmp = apply(:_Spnl) 4443 unless _tmp 4444 self.pos = _save 4445 break 4446 end 4447 _tmp = match_string("/") 4448 unless _tmp 4449 self.pos = _save 4450 break 4451 end 4452 4453 _save1 = self.pos 4454 while true # choice 4455 _tmp = match_string("h2") 4456 break if _tmp 4457 self.pos = _save1 4458 _tmp = match_string("H2") 4459 break if _tmp 4460 self.pos = _save1 4461 break 4462 end # end choice 4463 4464 unless _tmp 4465 self.pos = _save 4466 break 4467 end 4468 _tmp = apply(:_Spnl) 4469 unless _tmp 4470 self.pos = _save 4471 break 4472 end 4473 _tmp = match_string(">") 4474 unless _tmp 4475 self.pos = _save 4476 end 4477 break 4478 end # end sequence 4479 4480 set_failed_rule :_HtmlBlockCloseH2 unless _tmp 4481 return _tmp 4482 end 4483 4484 # HtmlBlockH2 = HtmlBlockOpenH2 (HtmlBlockH2 | !HtmlBlockCloseH2 .)* HtmlBlockCloseH2 4485 def _HtmlBlockH2 4486 4487 _save = self.pos 4488 while true # sequence 4489 _tmp = apply(:_HtmlBlockOpenH2) 4490 unless _tmp 4491 self.pos = _save 4492 break 4493 end 4494 while true 4495 4496 _save2 = self.pos 4497 while true # choice 4498 _tmp = apply(:_HtmlBlockH2) 4499 break if _tmp 4500 self.pos = _save2 4501 4502 _save3 = self.pos 4503 while true # sequence 4504 _save4 = self.pos 4505 _tmp = apply(:_HtmlBlockCloseH2) 4506 _tmp = _tmp ? nil : true 4507 self.pos = _save4 4508 unless _tmp 4509 self.pos = _save3 4510 break 4511 end 4512 _tmp = get_byte 4513 unless _tmp 4514 self.pos = _save3 4515 end 4516 break 4517 end # end sequence 4518 4519 break if _tmp 4520 self.pos = _save2 4521 break 4522 end # end choice 4523 4524 break unless _tmp 4525 end 4526 _tmp = true 4527 unless _tmp 4528 self.pos = _save 4529 break 4530 end 4531 _tmp = apply(:_HtmlBlockCloseH2) 4532 unless _tmp 4533 self.pos = _save 4534 end 4535 break 4536 end # end sequence 4537 4538 set_failed_rule :_HtmlBlockH2 unless _tmp 4539 return _tmp 4540 end 4541 4542 # HtmlBlockOpenH3 = "<" Spnl ("h3" | "H3") Spnl HtmlAttribute* ">" 4543 def _HtmlBlockOpenH3 4544 4545 _save = self.pos 4546 while true # sequence 4547 _tmp = match_string("<") 4548 unless _tmp 4549 self.pos = _save 4550 break 4551 end 4552 _tmp = apply(:_Spnl) 4553 unless _tmp 4554 self.pos = _save 4555 break 4556 end 4557 4558 _save1 = self.pos 4559 while true # choice 4560 _tmp = match_string("h3") 4561 break if _tmp 4562 self.pos = _save1 4563 _tmp = match_string("H3") 4564 break if _tmp 4565 self.pos = _save1 4566 break 4567 end # end choice 4568 4569 unless _tmp 4570 self.pos = _save 4571 break 4572 end 4573 _tmp = apply(:_Spnl) 4574 unless _tmp 4575 self.pos = _save 4576 break 4577 end 4578 while true 4579 _tmp = apply(:_HtmlAttribute) 4580 break unless _tmp 4581 end 4582 _tmp = true 4583 unless _tmp 4584 self.pos = _save 4585 break 4586 end 4587 _tmp = match_string(">") 4588 unless _tmp 4589 self.pos = _save 4590 end 4591 break 4592 end # end sequence 4593 4594 set_failed_rule :_HtmlBlockOpenH3 unless _tmp 4595 return _tmp 4596 end 4597 4598 # HtmlBlockCloseH3 = "<" Spnl "/" ("h3" | "H3") Spnl ">" 4599 def _HtmlBlockCloseH3 4600 4601 _save = self.pos 4602 while true # sequence 4603 _tmp = match_string("<") 4604 unless _tmp 4605 self.pos = _save 4606 break 4607 end 4608 _tmp = apply(:_Spnl) 4609 unless _tmp 4610 self.pos = _save 4611 break 4612 end 4613 _tmp = match_string("/") 4614 unless _tmp 4615 self.pos = _save 4616 break 4617 end 4618 4619 _save1 = self.pos 4620 while true # choice 4621 _tmp = match_string("h3") 4622 break if _tmp 4623 self.pos = _save1 4624 _tmp = match_string("H3") 4625 break if _tmp 4626 self.pos = _save1 4627 break 4628 end # end choice 4629 4630 unless _tmp 4631 self.pos = _save 4632 break 4633 end 4634 _tmp = apply(:_Spnl) 4635 unless _tmp 4636 self.pos = _save 4637 break 4638 end 4639 _tmp = match_string(">") 4640 unless _tmp 4641 self.pos = _save 4642 end 4643 break 4644 end # end sequence 4645 4646 set_failed_rule :_HtmlBlockCloseH3 unless _tmp 4647 return _tmp 4648 end 4649 4650 # HtmlBlockH3 = HtmlBlockOpenH3 (HtmlBlockH3 | !HtmlBlockCloseH3 .)* HtmlBlockCloseH3 4651 def _HtmlBlockH3 4652 4653 _save = self.pos 4654 while true # sequence 4655 _tmp = apply(:_HtmlBlockOpenH3) 4656 unless _tmp 4657 self.pos = _save 4658 break 4659 end 4660 while true 4661 4662 _save2 = self.pos 4663 while true # choice 4664 _tmp = apply(:_HtmlBlockH3) 4665 break if _tmp 4666 self.pos = _save2 4667 4668 _save3 = self.pos 4669 while true # sequence 4670 _save4 = self.pos 4671 _tmp = apply(:_HtmlBlockCloseH3) 4672 _tmp = _tmp ? nil : true 4673 self.pos = _save4 4674 unless _tmp 4675 self.pos = _save3 4676 break 4677 end 4678 _tmp = get_byte 4679 unless _tmp 4680 self.pos = _save3 4681 end 4682 break 4683 end # end sequence 4684 4685 break if _tmp 4686 self.pos = _save2 4687 break 4688 end # end choice 4689 4690 break unless _tmp 4691 end 4692 _tmp = true 4693 unless _tmp 4694 self.pos = _save 4695 break 4696 end 4697 _tmp = apply(:_HtmlBlockCloseH3) 4698 unless _tmp 4699 self.pos = _save 4700 end 4701 break 4702 end # end sequence 4703 4704 set_failed_rule :_HtmlBlockH3 unless _tmp 4705 return _tmp 4706 end 4707 4708 # HtmlBlockOpenH4 = "<" Spnl ("h4" | "H4") Spnl HtmlAttribute* ">" 4709 def _HtmlBlockOpenH4 4710 4711 _save = self.pos 4712 while true # sequence 4713 _tmp = match_string("<") 4714 unless _tmp 4715 self.pos = _save 4716 break 4717 end 4718 _tmp = apply(:_Spnl) 4719 unless _tmp 4720 self.pos = _save 4721 break 4722 end 4723 4724 _save1 = self.pos 4725 while true # choice 4726 _tmp = match_string("h4") 4727 break if _tmp 4728 self.pos = _save1 4729 _tmp = match_string("H4") 4730 break if _tmp 4731 self.pos = _save1 4732 break 4733 end # end choice 4734 4735 unless _tmp 4736 self.pos = _save 4737 break 4738 end 4739 _tmp = apply(:_Spnl) 4740 unless _tmp 4741 self.pos = _save 4742 break 4743 end 4744 while true 4745 _tmp = apply(:_HtmlAttribute) 4746 break unless _tmp 4747 end 4748 _tmp = true 4749 unless _tmp 4750 self.pos = _save 4751 break 4752 end 4753 _tmp = match_string(">") 4754 unless _tmp 4755 self.pos = _save 4756 end 4757 break 4758 end # end sequence 4759 4760 set_failed_rule :_HtmlBlockOpenH4 unless _tmp 4761 return _tmp 4762 end 4763 4764 # HtmlBlockCloseH4 = "<" Spnl "/" ("h4" | "H4") Spnl ">" 4765 def _HtmlBlockCloseH4 4766 4767 _save = self.pos 4768 while true # sequence 4769 _tmp = match_string("<") 4770 unless _tmp 4771 self.pos = _save 4772 break 4773 end 4774 _tmp = apply(:_Spnl) 4775 unless _tmp 4776 self.pos = _save 4777 break 4778 end 4779 _tmp = match_string("/") 4780 unless _tmp 4781 self.pos = _save 4782 break 4783 end 4784 4785 _save1 = self.pos 4786 while true # choice 4787 _tmp = match_string("h4") 4788 break if _tmp 4789 self.pos = _save1 4790 _tmp = match_string("H4") 4791 break if _tmp 4792 self.pos = _save1 4793 break 4794 end # end choice 4795 4796 unless _tmp 4797 self.pos = _save 4798 break 4799 end 4800 _tmp = apply(:_Spnl) 4801 unless _tmp 4802 self.pos = _save 4803 break 4804 end 4805 _tmp = match_string(">") 4806 unless _tmp 4807 self.pos = _save 4808 end 4809 break 4810 end # end sequence 4811 4812 set_failed_rule :_HtmlBlockCloseH4 unless _tmp 4813 return _tmp 4814 end 4815 4816 # HtmlBlockH4 = HtmlBlockOpenH4 (HtmlBlockH4 | !HtmlBlockCloseH4 .)* HtmlBlockCloseH4 4817 def _HtmlBlockH4 4818 4819 _save = self.pos 4820 while true # sequence 4821 _tmp = apply(:_HtmlBlockOpenH4) 4822 unless _tmp 4823 self.pos = _save 4824 break 4825 end 4826 while true 4827 4828 _save2 = self.pos 4829 while true # choice 4830 _tmp = apply(:_HtmlBlockH4) 4831 break if _tmp 4832 self.pos = _save2 4833 4834 _save3 = self.pos 4835 while true # sequence 4836 _save4 = self.pos 4837 _tmp = apply(:_HtmlBlockCloseH4) 4838 _tmp = _tmp ? nil : true 4839 self.pos = _save4 4840 unless _tmp 4841 self.pos = _save3 4842 break 4843 end 4844 _tmp = get_byte 4845 unless _tmp 4846 self.pos = _save3 4847 end 4848 break 4849 end # end sequence 4850 4851 break if _tmp 4852 self.pos = _save2 4853 break 4854 end # end choice 4855 4856 break unless _tmp 4857 end 4858 _tmp = true 4859 unless _tmp 4860 self.pos = _save 4861 break 4862 end 4863 _tmp = apply(:_HtmlBlockCloseH4) 4864 unless _tmp 4865 self.pos = _save 4866 end 4867 break 4868 end # end sequence 4869 4870 set_failed_rule :_HtmlBlockH4 unless _tmp 4871 return _tmp 4872 end 4873 4874 # HtmlBlockOpenH5 = "<" Spnl ("h5" | "H5") Spnl HtmlAttribute* ">" 4875 def _HtmlBlockOpenH5 4876 4877 _save = self.pos 4878 while true # sequence 4879 _tmp = match_string("<") 4880 unless _tmp 4881 self.pos = _save 4882 break 4883 end 4884 _tmp = apply(:_Spnl) 4885 unless _tmp 4886 self.pos = _save 4887 break 4888 end 4889 4890 _save1 = self.pos 4891 while true # choice 4892 _tmp = match_string("h5") 4893 break if _tmp 4894 self.pos = _save1 4895 _tmp = match_string("H5") 4896 break if _tmp 4897 self.pos = _save1 4898 break 4899 end # end choice 4900 4901 unless _tmp 4902 self.pos = _save 4903 break 4904 end 4905 _tmp = apply(:_Spnl) 4906 unless _tmp 4907 self.pos = _save 4908 break 4909 end 4910 while true 4911 _tmp = apply(:_HtmlAttribute) 4912 break unless _tmp 4913 end 4914 _tmp = true 4915 unless _tmp 4916 self.pos = _save 4917 break 4918 end 4919 _tmp = match_string(">") 4920 unless _tmp 4921 self.pos = _save 4922 end 4923 break 4924 end # end sequence 4925 4926 set_failed_rule :_HtmlBlockOpenH5 unless _tmp 4927 return _tmp 4928 end 4929 4930 # HtmlBlockCloseH5 = "<" Spnl "/" ("h5" | "H5") Spnl ">" 4931 def _HtmlBlockCloseH5 4932 4933 _save = self.pos 4934 while true # sequence 4935 _tmp = match_string("<") 4936 unless _tmp 4937 self.pos = _save 4938 break 4939 end 4940 _tmp = apply(:_Spnl) 4941 unless _tmp 4942 self.pos = _save 4943 break 4944 end 4945 _tmp = match_string("/") 4946 unless _tmp 4947 self.pos = _save 4948 break 4949 end 4950 4951 _save1 = self.pos 4952 while true # choice 4953 _tmp = match_string("h5") 4954 break if _tmp 4955 self.pos = _save1 4956 _tmp = match_string("H5") 4957 break if _tmp 4958 self.pos = _save1 4959 break 4960 end # end choice 4961 4962 unless _tmp 4963 self.pos = _save 4964 break 4965 end 4966 _tmp = apply(:_Spnl) 4967 unless _tmp 4968 self.pos = _save 4969 break 4970 end 4971 _tmp = match_string(">") 4972 unless _tmp 4973 self.pos = _save 4974 end 4975 break 4976 end # end sequence 4977 4978 set_failed_rule :_HtmlBlockCloseH5 unless _tmp 4979 return _tmp 4980 end 4981 4982 # HtmlBlockH5 = HtmlBlockOpenH5 (HtmlBlockH5 | !HtmlBlockCloseH5 .)* HtmlBlockCloseH5 4983 def _HtmlBlockH5 4984 4985 _save = self.pos 4986 while true # sequence 4987 _tmp = apply(:_HtmlBlockOpenH5) 4988 unless _tmp 4989 self.pos = _save 4990 break 4991 end 4992 while true 4993 4994 _save2 = self.pos 4995 while true # choice 4996 _tmp = apply(:_HtmlBlockH5) 4997 break if _tmp 4998 self.pos = _save2 4999 5000 _save3 = self.pos 5001 while true # sequence 5002 _save4 = self.pos 5003 _tmp = apply(:_HtmlBlockCloseH5) 5004 _tmp = _tmp ? nil : true 5005 self.pos = _save4 5006 unless _tmp 5007 self.pos = _save3 5008 break 5009 end 5010 _tmp = get_byte 5011 unless _tmp 5012 self.pos = _save3 5013 end 5014 break 5015 end # end sequence 5016 5017 break if _tmp 5018 self.pos = _save2 5019 break 5020 end # end choice 5021 5022 break unless _tmp 5023 end 5024 _tmp = true 5025 unless _tmp 5026 self.pos = _save 5027 break 5028 end 5029 _tmp = apply(:_HtmlBlockCloseH5) 5030 unless _tmp 5031 self.pos = _save 5032 end 5033 break 5034 end # end sequence 5035 5036 set_failed_rule :_HtmlBlockH5 unless _tmp 5037 return _tmp 5038 end 5039 5040 # HtmlBlockOpenH6 = "<" Spnl ("h6" | "H6") Spnl HtmlAttribute* ">" 5041 def _HtmlBlockOpenH6 5042 5043 _save = self.pos 5044 while true # sequence 5045 _tmp = match_string("<") 5046 unless _tmp 5047 self.pos = _save 5048 break 5049 end 5050 _tmp = apply(:_Spnl) 5051 unless _tmp 5052 self.pos = _save 5053 break 5054 end 5055 5056 _save1 = self.pos 5057 while true # choice 5058 _tmp = match_string("h6") 5059 break if _tmp 5060 self.pos = _save1 5061 _tmp = match_string("H6") 5062 break if _tmp 5063 self.pos = _save1 5064 break 5065 end # end choice 5066 5067 unless _tmp 5068 self.pos = _save 5069 break 5070 end 5071 _tmp = apply(:_Spnl) 5072 unless _tmp 5073 self.pos = _save 5074 break 5075 end 5076 while true 5077 _tmp = apply(:_HtmlAttribute) 5078 break unless _tmp 5079 end 5080 _tmp = true 5081 unless _tmp 5082 self.pos = _save 5083 break 5084 end 5085 _tmp = match_string(">") 5086 unless _tmp 5087 self.pos = _save 5088 end 5089 break 5090 end # end sequence 5091 5092 set_failed_rule :_HtmlBlockOpenH6 unless _tmp 5093 return _tmp 5094 end 5095 5096 # HtmlBlockCloseH6 = "<" Spnl "/" ("h6" | "H6") Spnl ">" 5097 def _HtmlBlockCloseH6 5098 5099 _save = self.pos 5100 while true # sequence 5101 _tmp = match_string("<") 5102 unless _tmp 5103 self.pos = _save 5104 break 5105 end 5106 _tmp = apply(:_Spnl) 5107 unless _tmp 5108 self.pos = _save 5109 break 5110 end 5111 _tmp = match_string("/") 5112 unless _tmp 5113 self.pos = _save 5114 break 5115 end 5116 5117 _save1 = self.pos 5118 while true # choice 5119 _tmp = match_string("h6") 5120 break if _tmp 5121 self.pos = _save1 5122 _tmp = match_string("H6") 5123 break if _tmp 5124 self.pos = _save1 5125 break 5126 end # end choice 5127 5128 unless _tmp 5129 self.pos = _save 5130 break 5131 end 5132 _tmp = apply(:_Spnl) 5133 unless _tmp 5134 self.pos = _save 5135 break 5136 end 5137 _tmp = match_string(">") 5138 unless _tmp 5139 self.pos = _save 5140 end 5141 break 5142 end # end sequence 5143 5144 set_failed_rule :_HtmlBlockCloseH6 unless _tmp 5145 return _tmp 5146 end 5147 5148 # HtmlBlockH6 = HtmlBlockOpenH6 (HtmlBlockH6 | !HtmlBlockCloseH6 .)* HtmlBlockCloseH6 5149 def _HtmlBlockH6 5150 5151 _save = self.pos 5152 while true # sequence 5153 _tmp = apply(:_HtmlBlockOpenH6) 5154 unless _tmp 5155 self.pos = _save 5156 break 5157 end 5158 while true 5159 5160 _save2 = self.pos 5161 while true # choice 5162 _tmp = apply(:_HtmlBlockH6) 5163 break if _tmp 5164 self.pos = _save2 5165 5166 _save3 = self.pos 5167 while true # sequence 5168 _save4 = self.pos 5169 _tmp = apply(:_HtmlBlockCloseH6) 5170 _tmp = _tmp ? nil : true 5171 self.pos = _save4 5172 unless _tmp 5173 self.pos = _save3 5174 break 5175 end 5176 _tmp = get_byte 5177 unless _tmp 5178 self.pos = _save3 5179 end 5180 break 5181 end # end sequence 5182 5183 break if _tmp 5184 self.pos = _save2 5185 break 5186 end # end choice 5187 5188 break unless _tmp 5189 end 5190 _tmp = true 5191 unless _tmp 5192 self.pos = _save 5193 break 5194 end 5195 _tmp = apply(:_HtmlBlockCloseH6) 5196 unless _tmp 5197 self.pos = _save 5198 end 5199 break 5200 end # end sequence 5201 5202 set_failed_rule :_HtmlBlockH6 unless _tmp 5203 return _tmp 5204 end 5205 5206 # HtmlBlockOpenMenu = "<" Spnl ("menu" | "MENU") Spnl HtmlAttribute* ">" 5207 def _HtmlBlockOpenMenu 5208 5209 _save = self.pos 5210 while true # sequence 5211 _tmp = match_string("<") 5212 unless _tmp 5213 self.pos = _save 5214 break 5215 end 5216 _tmp = apply(:_Spnl) 5217 unless _tmp 5218 self.pos = _save 5219 break 5220 end 5221 5222 _save1 = self.pos 5223 while true # choice 5224 _tmp = match_string("menu") 5225 break if _tmp 5226 self.pos = _save1 5227 _tmp = match_string("MENU") 5228 break if _tmp 5229 self.pos = _save1 5230 break 5231 end # end choice 5232 5233 unless _tmp 5234 self.pos = _save 5235 break 5236 end 5237 _tmp = apply(:_Spnl) 5238 unless _tmp 5239 self.pos = _save 5240 break 5241 end 5242 while true 5243 _tmp = apply(:_HtmlAttribute) 5244 break unless _tmp 5245 end 5246 _tmp = true 5247 unless _tmp 5248 self.pos = _save 5249 break 5250 end 5251 _tmp = match_string(">") 5252 unless _tmp 5253 self.pos = _save 5254 end 5255 break 5256 end # end sequence 5257 5258 set_failed_rule :_HtmlBlockOpenMenu unless _tmp 5259 return _tmp 5260 end 5261 5262 # HtmlBlockCloseMenu = "<" Spnl "/" ("menu" | "MENU") Spnl ">" 5263 def _HtmlBlockCloseMenu 5264 5265 _save = self.pos 5266 while true # sequence 5267 _tmp = match_string("<") 5268 unless _tmp 5269 self.pos = _save 5270 break 5271 end 5272 _tmp = apply(:_Spnl) 5273 unless _tmp 5274 self.pos = _save 5275 break 5276 end 5277 _tmp = match_string("/") 5278 unless _tmp 5279 self.pos = _save 5280 break 5281 end 5282 5283 _save1 = self.pos 5284 while true # choice 5285 _tmp = match_string("menu") 5286 break if _tmp 5287 self.pos = _save1 5288 _tmp = match_string("MENU") 5289 break if _tmp 5290 self.pos = _save1 5291 break 5292 end # end choice 5293 5294 unless _tmp 5295 self.pos = _save 5296 break 5297 end 5298 _tmp = apply(:_Spnl) 5299 unless _tmp 5300 self.pos = _save 5301 break 5302 end 5303 _tmp = match_string(">") 5304 unless _tmp 5305 self.pos = _save 5306 end 5307 break 5308 end # end sequence 5309 5310 set_failed_rule :_HtmlBlockCloseMenu unless _tmp 5311 return _tmp 5312 end 5313 5314 # HtmlBlockMenu = HtmlBlockOpenMenu (HtmlBlockMenu | !HtmlBlockCloseMenu .)* HtmlBlockCloseMenu 5315 def _HtmlBlockMenu 5316 5317 _save = self.pos 5318 while true # sequence 5319 _tmp = apply(:_HtmlBlockOpenMenu) 5320 unless _tmp 5321 self.pos = _save 5322 break 5323 end 5324 while true 5325 5326 _save2 = self.pos 5327 while true # choice 5328 _tmp = apply(:_HtmlBlockMenu) 5329 break if _tmp 5330 self.pos = _save2 5331 5332 _save3 = self.pos 5333 while true # sequence 5334 _save4 = self.pos 5335 _tmp = apply(:_HtmlBlockCloseMenu) 5336 _tmp = _tmp ? nil : true 5337 self.pos = _save4 5338 unless _tmp 5339 self.pos = _save3 5340 break 5341 end 5342 _tmp = get_byte 5343 unless _tmp 5344 self.pos = _save3 5345 end 5346 break 5347 end # end sequence 5348 5349 break if _tmp 5350 self.pos = _save2 5351 break 5352 end # end choice 5353 5354 break unless _tmp 5355 end 5356 _tmp = true 5357 unless _tmp 5358 self.pos = _save 5359 break 5360 end 5361 _tmp = apply(:_HtmlBlockCloseMenu) 5362 unless _tmp 5363 self.pos = _save 5364 end 5365 break 5366 end # end sequence 5367 5368 set_failed_rule :_HtmlBlockMenu unless _tmp 5369 return _tmp 5370 end 5371 5372 # HtmlBlockOpenNoframes = "<" Spnl ("noframes" | "NOFRAMES") Spnl HtmlAttribute* ">" 5373 def _HtmlBlockOpenNoframes 5374 5375 _save = self.pos 5376 while true # sequence 5377 _tmp = match_string("<") 5378 unless _tmp 5379 self.pos = _save 5380 break 5381 end 5382 _tmp = apply(:_Spnl) 5383 unless _tmp 5384 self.pos = _save 5385 break 5386 end 5387 5388 _save1 = self.pos 5389 while true # choice 5390 _tmp = match_string("noframes") 5391 break if _tmp 5392 self.pos = _save1 5393 _tmp = match_string("NOFRAMES") 5394 break if _tmp 5395 self.pos = _save1 5396 break 5397 end # end choice 5398 5399 unless _tmp 5400 self.pos = _save 5401 break 5402 end 5403 _tmp = apply(:_Spnl) 5404 unless _tmp 5405 self.pos = _save 5406 break 5407 end 5408 while true 5409 _tmp = apply(:_HtmlAttribute) 5410 break unless _tmp 5411 end 5412 _tmp = true 5413 unless _tmp 5414 self.pos = _save 5415 break 5416 end 5417 _tmp = match_string(">") 5418 unless _tmp 5419 self.pos = _save 5420 end 5421 break 5422 end # end sequence 5423 5424 set_failed_rule :_HtmlBlockOpenNoframes unless _tmp 5425 return _tmp 5426 end 5427 5428 # HtmlBlockCloseNoframes = "<" Spnl "/" ("noframes" | "NOFRAMES") Spnl ">" 5429 def _HtmlBlockCloseNoframes 5430 5431 _save = self.pos 5432 while true # sequence 5433 _tmp = match_string("<") 5434 unless _tmp 5435 self.pos = _save 5436 break 5437 end 5438 _tmp = apply(:_Spnl) 5439 unless _tmp 5440 self.pos = _save 5441 break 5442 end 5443 _tmp = match_string("/") 5444 unless _tmp 5445 self.pos = _save 5446 break 5447 end 5448 5449 _save1 = self.pos 5450 while true # choice 5451 _tmp = match_string("noframes") 5452 break if _tmp 5453 self.pos = _save1 5454 _tmp = match_string("NOFRAMES") 5455 break if _tmp 5456 self.pos = _save1 5457 break 5458 end # end choice 5459 5460 unless _tmp 5461 self.pos = _save 5462 break 5463 end 5464 _tmp = apply(:_Spnl) 5465 unless _tmp 5466 self.pos = _save 5467 break 5468 end 5469 _tmp = match_string(">") 5470 unless _tmp 5471 self.pos = _save 5472 end 5473 break 5474 end # end sequence 5475 5476 set_failed_rule :_HtmlBlockCloseNoframes unless _tmp 5477 return _tmp 5478 end 5479 5480 # HtmlBlockNoframes = HtmlBlockOpenNoframes (HtmlBlockNoframes | !HtmlBlockCloseNoframes .)* HtmlBlockCloseNoframes 5481 def _HtmlBlockNoframes 5482 5483 _save = self.pos 5484 while true # sequence 5485 _tmp = apply(:_HtmlBlockOpenNoframes) 5486 unless _tmp 5487 self.pos = _save 5488 break 5489 end 5490 while true 5491 5492 _save2 = self.pos 5493 while true # choice 5494 _tmp = apply(:_HtmlBlockNoframes) 5495 break if _tmp 5496 self.pos = _save2 5497 5498 _save3 = self.pos 5499 while true # sequence 5500 _save4 = self.pos 5501 _tmp = apply(:_HtmlBlockCloseNoframes) 5502 _tmp = _tmp ? nil : true 5503 self.pos = _save4 5504 unless _tmp 5505 self.pos = _save3 5506 break 5507 end 5508 _tmp = get_byte 5509 unless _tmp 5510 self.pos = _save3 5511 end 5512 break 5513 end # end sequence 5514 5515 break if _tmp 5516 self.pos = _save2 5517 break 5518 end # end choice 5519 5520 break unless _tmp 5521 end 5522 _tmp = true 5523 unless _tmp 5524 self.pos = _save 5525 break 5526 end 5527 _tmp = apply(:_HtmlBlockCloseNoframes) 5528 unless _tmp 5529 self.pos = _save 5530 end 5531 break 5532 end # end sequence 5533 5534 set_failed_rule :_HtmlBlockNoframes unless _tmp 5535 return _tmp 5536 end 5537 5538 # HtmlBlockOpenNoscript = "<" Spnl ("noscript" | "NOSCRIPT") Spnl HtmlAttribute* ">" 5539 def _HtmlBlockOpenNoscript 5540 5541 _save = self.pos 5542 while true # sequence 5543 _tmp = match_string("<") 5544 unless _tmp 5545 self.pos = _save 5546 break 5547 end 5548 _tmp = apply(:_Spnl) 5549 unless _tmp 5550 self.pos = _save 5551 break 5552 end 5553 5554 _save1 = self.pos 5555 while true # choice 5556 _tmp = match_string("noscript") 5557 break if _tmp 5558 self.pos = _save1 5559 _tmp = match_string("NOSCRIPT") 5560 break if _tmp 5561 self.pos = _save1 5562 break 5563 end # end choice 5564 5565 unless _tmp 5566 self.pos = _save 5567 break 5568 end 5569 _tmp = apply(:_Spnl) 5570 unless _tmp 5571 self.pos = _save 5572 break 5573 end 5574 while true 5575 _tmp = apply(:_HtmlAttribute) 5576 break unless _tmp 5577 end 5578 _tmp = true 5579 unless _tmp 5580 self.pos = _save 5581 break 5582 end 5583 _tmp = match_string(">") 5584 unless _tmp 5585 self.pos = _save 5586 end 5587 break 5588 end # end sequence 5589 5590 set_failed_rule :_HtmlBlockOpenNoscript unless _tmp 5591 return _tmp 5592 end 5593 5594 # HtmlBlockCloseNoscript = "<" Spnl "/" ("noscript" | "NOSCRIPT") Spnl ">" 5595 def _HtmlBlockCloseNoscript 5596 5597 _save = self.pos 5598 while true # sequence 5599 _tmp = match_string("<") 5600 unless _tmp 5601 self.pos = _save 5602 break 5603 end 5604 _tmp = apply(:_Spnl) 5605 unless _tmp 5606 self.pos = _save 5607 break 5608 end 5609 _tmp = match_string("/") 5610 unless _tmp 5611 self.pos = _save 5612 break 5613 end 5614 5615 _save1 = self.pos 5616 while true # choice 5617 _tmp = match_string("noscript") 5618 break if _tmp 5619 self.pos = _save1 5620 _tmp = match_string("NOSCRIPT") 5621 break if _tmp 5622 self.pos = _save1 5623 break 5624 end # end choice 5625 5626 unless _tmp 5627 self.pos = _save 5628 break 5629 end 5630 _tmp = apply(:_Spnl) 5631 unless _tmp 5632 self.pos = _save 5633 break 5634 end 5635 _tmp = match_string(">") 5636 unless _tmp 5637 self.pos = _save 5638 end 5639 break 5640 end # end sequence 5641 5642 set_failed_rule :_HtmlBlockCloseNoscript unless _tmp 5643 return _tmp 5644 end 5645 5646 # HtmlBlockNoscript = HtmlBlockOpenNoscript (HtmlBlockNoscript | !HtmlBlockCloseNoscript .)* HtmlBlockCloseNoscript 5647 def _HtmlBlockNoscript 5648 5649 _save = self.pos 5650 while true # sequence 5651 _tmp = apply(:_HtmlBlockOpenNoscript) 5652 unless _tmp 5653 self.pos = _save 5654 break 5655 end 5656 while true 5657 5658 _save2 = self.pos 5659 while true # choice 5660 _tmp = apply(:_HtmlBlockNoscript) 5661 break if _tmp 5662 self.pos = _save2 5663 5664 _save3 = self.pos 5665 while true # sequence 5666 _save4 = self.pos 5667 _tmp = apply(:_HtmlBlockCloseNoscript) 5668 _tmp = _tmp ? nil : true 5669 self.pos = _save4 5670 unless _tmp 5671 self.pos = _save3 5672 break 5673 end 5674 _tmp = get_byte 5675 unless _tmp 5676 self.pos = _save3 5677 end 5678 break 5679 end # end sequence 5680 5681 break if _tmp 5682 self.pos = _save2 5683 break 5684 end # end choice 5685 5686 break unless _tmp 5687 end 5688 _tmp = true 5689 unless _tmp 5690 self.pos = _save 5691 break 5692 end 5693 _tmp = apply(:_HtmlBlockCloseNoscript) 5694 unless _tmp 5695 self.pos = _save 5696 end 5697 break 5698 end # end sequence 5699 5700 set_failed_rule :_HtmlBlockNoscript unless _tmp 5701 return _tmp 5702 end 5703 5704 # HtmlBlockOpenOl = "<" Spnl ("ol" | "OL") Spnl HtmlAttribute* ">" 5705 def _HtmlBlockOpenOl 5706 5707 _save = self.pos 5708 while true # sequence 5709 _tmp = match_string("<") 5710 unless _tmp 5711 self.pos = _save 5712 break 5713 end 5714 _tmp = apply(:_Spnl) 5715 unless _tmp 5716 self.pos = _save 5717 break 5718 end 5719 5720 _save1 = self.pos 5721 while true # choice 5722 _tmp = match_string("ol") 5723 break if _tmp 5724 self.pos = _save1 5725 _tmp = match_string("OL") 5726 break if _tmp 5727 self.pos = _save1 5728 break 5729 end # end choice 5730 5731 unless _tmp 5732 self.pos = _save 5733 break 5734 end 5735 _tmp = apply(:_Spnl) 5736 unless _tmp 5737 self.pos = _save 5738 break 5739 end 5740 while true 5741 _tmp = apply(:_HtmlAttribute) 5742 break unless _tmp 5743 end 5744 _tmp = true 5745 unless _tmp 5746 self.pos = _save 5747 break 5748 end 5749 _tmp = match_string(">") 5750 unless _tmp 5751 self.pos = _save 5752 end 5753 break 5754 end # end sequence 5755 5756 set_failed_rule :_HtmlBlockOpenOl unless _tmp 5757 return _tmp 5758 end 5759 5760 # HtmlBlockCloseOl = "<" Spnl "/" ("ol" | "OL") Spnl ">" 5761 def _HtmlBlockCloseOl 5762 5763 _save = self.pos 5764 while true # sequence 5765 _tmp = match_string("<") 5766 unless _tmp 5767 self.pos = _save 5768 break 5769 end 5770 _tmp = apply(:_Spnl) 5771 unless _tmp 5772 self.pos = _save 5773 break 5774 end 5775 _tmp = match_string("/") 5776 unless _tmp 5777 self.pos = _save 5778 break 5779 end 5780 5781 _save1 = self.pos 5782 while true # choice 5783 _tmp = match_string("ol") 5784 break if _tmp 5785 self.pos = _save1 5786 _tmp = match_string("OL") 5787 break if _tmp 5788 self.pos = _save1 5789 break 5790 end # end choice 5791 5792 unless _tmp 5793 self.pos = _save 5794 break 5795 end 5796 _tmp = apply(:_Spnl) 5797 unless _tmp 5798 self.pos = _save 5799 break 5800 end 5801 _tmp = match_string(">") 5802 unless _tmp 5803 self.pos = _save 5804 end 5805 break 5806 end # end sequence 5807 5808 set_failed_rule :_HtmlBlockCloseOl unless _tmp 5809 return _tmp 5810 end 5811 5812 # HtmlBlockOl = HtmlBlockOpenOl (HtmlBlockOl | !HtmlBlockCloseOl .)* HtmlBlockCloseOl 5813 def _HtmlBlockOl 5814 5815 _save = self.pos 5816 while true # sequence 5817 _tmp = apply(:_HtmlBlockOpenOl) 5818 unless _tmp 5819 self.pos = _save 5820 break 5821 end 5822 while true 5823 5824 _save2 = self.pos 5825 while true # choice 5826 _tmp = apply(:_HtmlBlockOl) 5827 break if _tmp 5828 self.pos = _save2 5829 5830 _save3 = self.pos 5831 while true # sequence 5832 _save4 = self.pos 5833 _tmp = apply(:_HtmlBlockCloseOl) 5834 _tmp = _tmp ? nil : true 5835 self.pos = _save4 5836 unless _tmp 5837 self.pos = _save3 5838 break 5839 end 5840 _tmp = get_byte 5841 unless _tmp 5842 self.pos = _save3 5843 end 5844 break 5845 end # end sequence 5846 5847 break if _tmp 5848 self.pos = _save2 5849 break 5850 end # end choice 5851 5852 break unless _tmp 5853 end 5854 _tmp = true 5855 unless _tmp 5856 self.pos = _save 5857 break 5858 end 5859 _tmp = apply(:_HtmlBlockCloseOl) 5860 unless _tmp 5861 self.pos = _save 5862 end 5863 break 5864 end # end sequence 5865 5866 set_failed_rule :_HtmlBlockOl unless _tmp 5867 return _tmp 5868 end 5869 5870 # HtmlBlockOpenP = "<" Spnl ("p" | "P") Spnl HtmlAttribute* ">" 5871 def _HtmlBlockOpenP 5872 5873 _save = self.pos 5874 while true # sequence 5875 _tmp = match_string("<") 5876 unless _tmp 5877 self.pos = _save 5878 break 5879 end 5880 _tmp = apply(:_Spnl) 5881 unless _tmp 5882 self.pos = _save 5883 break 5884 end 5885 5886 _save1 = self.pos 5887 while true # choice 5888 _tmp = match_string("p") 5889 break if _tmp 5890 self.pos = _save1 5891 _tmp = match_string("P") 5892 break if _tmp 5893 self.pos = _save1 5894 break 5895 end # end choice 5896 5897 unless _tmp 5898 self.pos = _save 5899 break 5900 end 5901 _tmp = apply(:_Spnl) 5902 unless _tmp 5903 self.pos = _save 5904 break 5905 end 5906 while true 5907 _tmp = apply(:_HtmlAttribute) 5908 break unless _tmp 5909 end 5910 _tmp = true 5911 unless _tmp 5912 self.pos = _save 5913 break 5914 end 5915 _tmp = match_string(">") 5916 unless _tmp 5917 self.pos = _save 5918 end 5919 break 5920 end # end sequence 5921 5922 set_failed_rule :_HtmlBlockOpenP unless _tmp 5923 return _tmp 5924 end 5925 5926 # HtmlBlockCloseP = "<" Spnl "/" ("p" | "P") Spnl ">" 5927 def _HtmlBlockCloseP 5928 5929 _save = self.pos 5930 while true # sequence 5931 _tmp = match_string("<") 5932 unless _tmp 5933 self.pos = _save 5934 break 5935 end 5936 _tmp = apply(:_Spnl) 5937 unless _tmp 5938 self.pos = _save 5939 break 5940 end 5941 _tmp = match_string("/") 5942 unless _tmp 5943 self.pos = _save 5944 break 5945 end 5946 5947 _save1 = self.pos 5948 while true # choice 5949 _tmp = match_string("p") 5950 break if _tmp 5951 self.pos = _save1 5952 _tmp = match_string("P") 5953 break if _tmp 5954 self.pos = _save1 5955 break 5956 end # end choice 5957 5958 unless _tmp 5959 self.pos = _save 5960 break 5961 end 5962 _tmp = apply(:_Spnl) 5963 unless _tmp 5964 self.pos = _save 5965 break 5966 end 5967 _tmp = match_string(">") 5968 unless _tmp 5969 self.pos = _save 5970 end 5971 break 5972 end # end sequence 5973 5974 set_failed_rule :_HtmlBlockCloseP unless _tmp 5975 return _tmp 5976 end 5977 5978 # HtmlBlockP = HtmlBlockOpenP (HtmlBlockP | !HtmlBlockCloseP .)* HtmlBlockCloseP 5979 def _HtmlBlockP 5980 5981 _save = self.pos 5982 while true # sequence 5983 _tmp = apply(:_HtmlBlockOpenP) 5984 unless _tmp 5985 self.pos = _save 5986 break 5987 end 5988 while true 5989 5990 _save2 = self.pos 5991 while true # choice 5992 _tmp = apply(:_HtmlBlockP) 5993 break if _tmp 5994 self.pos = _save2 5995 5996 _save3 = self.pos 5997 while true # sequence 5998 _save4 = self.pos 5999 _tmp = apply(:_HtmlBlockCloseP) 6000 _tmp = _tmp ? nil : true 6001 self.pos = _save4 6002 unless _tmp 6003 self.pos = _save3 6004 break 6005 end 6006 _tmp = get_byte 6007 unless _tmp 6008 self.pos = _save3 6009 end 6010 break 6011 end # end sequence 6012 6013 break if _tmp 6014 self.pos = _save2 6015 break 6016 end # end choice 6017 6018 break unless _tmp 6019 end 6020 _tmp = true 6021 unless _tmp 6022 self.pos = _save 6023 break 6024 end 6025 _tmp = apply(:_HtmlBlockCloseP) 6026 unless _tmp 6027 self.pos = _save 6028 end 6029 break 6030 end # end sequence 6031 6032 set_failed_rule :_HtmlBlockP unless _tmp 6033 return _tmp 6034 end 6035 6036 # HtmlBlockOpenPre = "<" Spnl ("pre" | "PRE") Spnl HtmlAttribute* ">" 6037 def _HtmlBlockOpenPre 6038 6039 _save = self.pos 6040 while true # sequence 6041 _tmp = match_string("<") 6042 unless _tmp 6043 self.pos = _save 6044 break 6045 end 6046 _tmp = apply(:_Spnl) 6047 unless _tmp 6048 self.pos = _save 6049 break 6050 end 6051 6052 _save1 = self.pos 6053 while true # choice 6054 _tmp = match_string("pre") 6055 break if _tmp 6056 self.pos = _save1 6057 _tmp = match_string("PRE") 6058 break if _tmp 6059 self.pos = _save1 6060 break 6061 end # end choice 6062 6063 unless _tmp 6064 self.pos = _save 6065 break 6066 end 6067 _tmp = apply(:_Spnl) 6068 unless _tmp 6069 self.pos = _save 6070 break 6071 end 6072 while true 6073 _tmp = apply(:_HtmlAttribute) 6074 break unless _tmp 6075 end 6076 _tmp = true 6077 unless _tmp 6078 self.pos = _save 6079 break 6080 end 6081 _tmp = match_string(">") 6082 unless _tmp 6083 self.pos = _save 6084 end 6085 break 6086 end # end sequence 6087 6088 set_failed_rule :_HtmlBlockOpenPre unless _tmp 6089 return _tmp 6090 end 6091 6092 # HtmlBlockClosePre = "<" Spnl "/" ("pre" | "PRE") Spnl ">" 6093 def _HtmlBlockClosePre 6094 6095 _save = self.pos 6096 while true # sequence 6097 _tmp = match_string("<") 6098 unless _tmp 6099 self.pos = _save 6100 break 6101 end 6102 _tmp = apply(:_Spnl) 6103 unless _tmp 6104 self.pos = _save 6105 break 6106 end 6107 _tmp = match_string("/") 6108 unless _tmp 6109 self.pos = _save 6110 break 6111 end 6112 6113 _save1 = self.pos 6114 while true # choice 6115 _tmp = match_string("pre") 6116 break if _tmp 6117 self.pos = _save1 6118 _tmp = match_string("PRE") 6119 break if _tmp 6120 self.pos = _save1 6121 break 6122 end # end choice 6123 6124 unless _tmp 6125 self.pos = _save 6126 break 6127 end 6128 _tmp = apply(:_Spnl) 6129 unless _tmp 6130 self.pos = _save 6131 break 6132 end 6133 _tmp = match_string(">") 6134 unless _tmp 6135 self.pos = _save 6136 end 6137 break 6138 end # end sequence 6139 6140 set_failed_rule :_HtmlBlockClosePre unless _tmp 6141 return _tmp 6142 end 6143 6144 # HtmlBlockPre = HtmlBlockOpenPre (HtmlBlockPre | !HtmlBlockClosePre .)* HtmlBlockClosePre 6145 def _HtmlBlockPre 6146 6147 _save = self.pos 6148 while true # sequence 6149 _tmp = apply(:_HtmlBlockOpenPre) 6150 unless _tmp 6151 self.pos = _save 6152 break 6153 end 6154 while true 6155 6156 _save2 = self.pos 6157 while true # choice 6158 _tmp = apply(:_HtmlBlockPre) 6159 break if _tmp 6160 self.pos = _save2 6161 6162 _save3 = self.pos 6163 while true # sequence 6164 _save4 = self.pos 6165 _tmp = apply(:_HtmlBlockClosePre) 6166 _tmp = _tmp ? nil : true 6167 self.pos = _save4 6168 unless _tmp 6169 self.pos = _save3 6170 break 6171 end 6172 _tmp = get_byte 6173 unless _tmp 6174 self.pos = _save3 6175 end 6176 break 6177 end # end sequence 6178 6179 break if _tmp 6180 self.pos = _save2 6181 break 6182 end # end choice 6183 6184 break unless _tmp 6185 end 6186 _tmp = true 6187 unless _tmp 6188 self.pos = _save 6189 break 6190 end 6191 _tmp = apply(:_HtmlBlockClosePre) 6192 unless _tmp 6193 self.pos = _save 6194 end 6195 break 6196 end # end sequence 6197 6198 set_failed_rule :_HtmlBlockPre unless _tmp 6199 return _tmp 6200 end 6201 6202 # HtmlBlockOpenTable = "<" Spnl ("table" | "TABLE") Spnl HtmlAttribute* ">" 6203 def _HtmlBlockOpenTable 6204 6205 _save = self.pos 6206 while true # sequence 6207 _tmp = match_string("<") 6208 unless _tmp 6209 self.pos = _save 6210 break 6211 end 6212 _tmp = apply(:_Spnl) 6213 unless _tmp 6214 self.pos = _save 6215 break 6216 end 6217 6218 _save1 = self.pos 6219 while true # choice 6220 _tmp = match_string("table") 6221 break if _tmp 6222 self.pos = _save1 6223 _tmp = match_string("TABLE") 6224 break if _tmp 6225 self.pos = _save1 6226 break 6227 end # end choice 6228 6229 unless _tmp 6230 self.pos = _save 6231 break 6232 end 6233 _tmp = apply(:_Spnl) 6234 unless _tmp 6235 self.pos = _save 6236 break 6237 end 6238 while true 6239 _tmp = apply(:_HtmlAttribute) 6240 break unless _tmp 6241 end 6242 _tmp = true 6243 unless _tmp 6244 self.pos = _save 6245 break 6246 end 6247 _tmp = match_string(">") 6248 unless _tmp 6249 self.pos = _save 6250 end 6251 break 6252 end # end sequence 6253 6254 set_failed_rule :_HtmlBlockOpenTable unless _tmp 6255 return _tmp 6256 end 6257 6258 # HtmlBlockCloseTable = "<" Spnl "/" ("table" | "TABLE") Spnl ">" 6259 def _HtmlBlockCloseTable 6260 6261 _save = self.pos 6262 while true # sequence 6263 _tmp = match_string("<") 6264 unless _tmp 6265 self.pos = _save 6266 break 6267 end 6268 _tmp = apply(:_Spnl) 6269 unless _tmp 6270 self.pos = _save 6271 break 6272 end 6273 _tmp = match_string("/") 6274 unless _tmp 6275 self.pos = _save 6276 break 6277 end 6278 6279 _save1 = self.pos 6280 while true # choice 6281 _tmp = match_string("table") 6282 break if _tmp 6283 self.pos = _save1 6284 _tmp = match_string("TABLE") 6285 break if _tmp 6286 self.pos = _save1 6287 break 6288 end # end choice 6289 6290 unless _tmp 6291 self.pos = _save 6292 break 6293 end 6294 _tmp = apply(:_Spnl) 6295 unless _tmp 6296 self.pos = _save 6297 break 6298 end 6299 _tmp = match_string(">") 6300 unless _tmp 6301 self.pos = _save 6302 end 6303 break 6304 end # end sequence 6305 6306 set_failed_rule :_HtmlBlockCloseTable unless _tmp 6307 return _tmp 6308 end 6309 6310 # HtmlBlockTable = HtmlBlockOpenTable (HtmlBlockTable | !HtmlBlockCloseTable .)* HtmlBlockCloseTable 6311 def _HtmlBlockTable 6312 6313 _save = self.pos 6314 while true # sequence 6315 _tmp = apply(:_HtmlBlockOpenTable) 6316 unless _tmp 6317 self.pos = _save 6318 break 6319 end 6320 while true 6321 6322 _save2 = self.pos 6323 while true # choice 6324 _tmp = apply(:_HtmlBlockTable) 6325 break if _tmp 6326 self.pos = _save2 6327 6328 _save3 = self.pos 6329 while true # sequence 6330 _save4 = self.pos 6331 _tmp = apply(:_HtmlBlockCloseTable) 6332 _tmp = _tmp ? nil : true 6333 self.pos = _save4 6334 unless _tmp 6335 self.pos = _save3 6336 break 6337 end 6338 _tmp = get_byte 6339 unless _tmp 6340 self.pos = _save3 6341 end 6342 break 6343 end # end sequence 6344 6345 break if _tmp 6346 self.pos = _save2 6347 break 6348 end # end choice 6349 6350 break unless _tmp 6351 end 6352 _tmp = true 6353 unless _tmp 6354 self.pos = _save 6355 break 6356 end 6357 _tmp = apply(:_HtmlBlockCloseTable) 6358 unless _tmp 6359 self.pos = _save 6360 end 6361 break 6362 end # end sequence 6363 6364 set_failed_rule :_HtmlBlockTable unless _tmp 6365 return _tmp 6366 end 6367 6368 # HtmlBlockOpenUl = "<" Spnl ("ul" | "UL") Spnl HtmlAttribute* ">" 6369 def _HtmlBlockOpenUl 6370 6371 _save = self.pos 6372 while true # sequence 6373 _tmp = match_string("<") 6374 unless _tmp 6375 self.pos = _save 6376 break 6377 end 6378 _tmp = apply(:_Spnl) 6379 unless _tmp 6380 self.pos = _save 6381 break 6382 end 6383 6384 _save1 = self.pos 6385 while true # choice 6386 _tmp = match_string("ul") 6387 break if _tmp 6388 self.pos = _save1 6389 _tmp = match_string("UL") 6390 break if _tmp 6391 self.pos = _save1 6392 break 6393 end # end choice 6394 6395 unless _tmp 6396 self.pos = _save 6397 break 6398 end 6399 _tmp = apply(:_Spnl) 6400 unless _tmp 6401 self.pos = _save 6402 break 6403 end 6404 while true 6405 _tmp = apply(:_HtmlAttribute) 6406 break unless _tmp 6407 end 6408 _tmp = true 6409 unless _tmp 6410 self.pos = _save 6411 break 6412 end 6413 _tmp = match_string(">") 6414 unless _tmp 6415 self.pos = _save 6416 end 6417 break 6418 end # end sequence 6419 6420 set_failed_rule :_HtmlBlockOpenUl unless _tmp 6421 return _tmp 6422 end 6423 6424 # HtmlBlockCloseUl = "<" Spnl "/" ("ul" | "UL") Spnl ">" 6425 def _HtmlBlockCloseUl 6426 6427 _save = self.pos 6428 while true # sequence 6429 _tmp = match_string("<") 6430 unless _tmp 6431 self.pos = _save 6432 break 6433 end 6434 _tmp = apply(:_Spnl) 6435 unless _tmp 6436 self.pos = _save 6437 break 6438 end 6439 _tmp = match_string("/") 6440 unless _tmp 6441 self.pos = _save 6442 break 6443 end 6444 6445 _save1 = self.pos 6446 while true # choice 6447 _tmp = match_string("ul") 6448 break if _tmp 6449 self.pos = _save1 6450 _tmp = match_string("UL") 6451 break if _tmp 6452 self.pos = _save1 6453 break 6454 end # end choice 6455 6456 unless _tmp 6457 self.pos = _save 6458 break 6459 end 6460 _tmp = apply(:_Spnl) 6461 unless _tmp 6462 self.pos = _save 6463 break 6464 end 6465 _tmp = match_string(">") 6466 unless _tmp 6467 self.pos = _save 6468 end 6469 break 6470 end # end sequence 6471 6472 set_failed_rule :_HtmlBlockCloseUl unless _tmp 6473 return _tmp 6474 end 6475 6476 # HtmlBlockUl = HtmlBlockOpenUl (HtmlBlockUl | !HtmlBlockCloseUl .)* HtmlBlockCloseUl 6477 def _HtmlBlockUl 6478 6479 _save = self.pos 6480 while true # sequence 6481 _tmp = apply(:_HtmlBlockOpenUl) 6482 unless _tmp 6483 self.pos = _save 6484 break 6485 end 6486 while true 6487 6488 _save2 = self.pos 6489 while true # choice 6490 _tmp = apply(:_HtmlBlockUl) 6491 break if _tmp 6492 self.pos = _save2 6493 6494 _save3 = self.pos 6495 while true # sequence 6496 _save4 = self.pos 6497 _tmp = apply(:_HtmlBlockCloseUl) 6498 _tmp = _tmp ? nil : true 6499 self.pos = _save4 6500 unless _tmp 6501 self.pos = _save3 6502 break 6503 end 6504 _tmp = get_byte 6505 unless _tmp 6506 self.pos = _save3 6507 end 6508 break 6509 end # end sequence 6510 6511 break if _tmp 6512 self.pos = _save2 6513 break 6514 end # end choice 6515 6516 break unless _tmp 6517 end 6518 _tmp = true 6519 unless _tmp 6520 self.pos = _save 6521 break 6522 end 6523 _tmp = apply(:_HtmlBlockCloseUl) 6524 unless _tmp 6525 self.pos = _save 6526 end 6527 break 6528 end # end sequence 6529 6530 set_failed_rule :_HtmlBlockUl unless _tmp 6531 return _tmp 6532 end 6533 6534 # HtmlBlockOpenDd = "<" Spnl ("dd" | "DD") Spnl HtmlAttribute* ">" 6535 def _HtmlBlockOpenDd 6536 6537 _save = self.pos 6538 while true # sequence 6539 _tmp = match_string("<") 6540 unless _tmp 6541 self.pos = _save 6542 break 6543 end 6544 _tmp = apply(:_Spnl) 6545 unless _tmp 6546 self.pos = _save 6547 break 6548 end 6549 6550 _save1 = self.pos 6551 while true # choice 6552 _tmp = match_string("dd") 6553 break if _tmp 6554 self.pos = _save1 6555 _tmp = match_string("DD") 6556 break if _tmp 6557 self.pos = _save1 6558 break 6559 end # end choice 6560 6561 unless _tmp 6562 self.pos = _save 6563 break 6564 end 6565 _tmp = apply(:_Spnl) 6566 unless _tmp 6567 self.pos = _save 6568 break 6569 end 6570 while true 6571 _tmp = apply(:_HtmlAttribute) 6572 break unless _tmp 6573 end 6574 _tmp = true 6575 unless _tmp 6576 self.pos = _save 6577 break 6578 end 6579 _tmp = match_string(">") 6580 unless _tmp 6581 self.pos = _save 6582 end 6583 break 6584 end # end sequence 6585 6586 set_failed_rule :_HtmlBlockOpenDd unless _tmp 6587 return _tmp 6588 end 6589 6590 # HtmlBlockCloseDd = "<" Spnl "/" ("dd" | "DD") Spnl ">" 6591 def _HtmlBlockCloseDd 6592 6593 _save = self.pos 6594 while true # sequence 6595 _tmp = match_string("<") 6596 unless _tmp 6597 self.pos = _save 6598 break 6599 end 6600 _tmp = apply(:_Spnl) 6601 unless _tmp 6602 self.pos = _save 6603 break 6604 end 6605 _tmp = match_string("/") 6606 unless _tmp 6607 self.pos = _save 6608 break 6609 end 6610 6611 _save1 = self.pos 6612 while true # choice 6613 _tmp = match_string("dd") 6614 break if _tmp 6615 self.pos = _save1 6616 _tmp = match_string("DD") 6617 break if _tmp 6618 self.pos = _save1 6619 break 6620 end # end choice 6621 6622 unless _tmp 6623 self.pos = _save 6624 break 6625 end 6626 _tmp = apply(:_Spnl) 6627 unless _tmp 6628 self.pos = _save 6629 break 6630 end 6631 _tmp = match_string(">") 6632 unless _tmp 6633 self.pos = _save 6634 end 6635 break 6636 end # end sequence 6637 6638 set_failed_rule :_HtmlBlockCloseDd unless _tmp 6639 return _tmp 6640 end 6641 6642 # HtmlBlockDd = HtmlBlockOpenDd (HtmlBlockDd | !HtmlBlockCloseDd .)* HtmlBlockCloseDd 6643 def _HtmlBlockDd 6644 6645 _save = self.pos 6646 while true # sequence 6647 _tmp = apply(:_HtmlBlockOpenDd) 6648 unless _tmp 6649 self.pos = _save 6650 break 6651 end 6652 while true 6653 6654 _save2 = self.pos 6655 while true # choice 6656 _tmp = apply(:_HtmlBlockDd) 6657 break if _tmp 6658 self.pos = _save2 6659 6660 _save3 = self.pos 6661 while true # sequence 6662 _save4 = self.pos 6663 _tmp = apply(:_HtmlBlockCloseDd) 6664 _tmp = _tmp ? nil : true 6665 self.pos = _save4 6666 unless _tmp 6667 self.pos = _save3 6668 break 6669 end 6670 _tmp = get_byte 6671 unless _tmp 6672 self.pos = _save3 6673 end 6674 break 6675 end # end sequence 6676 6677 break if _tmp 6678 self.pos = _save2 6679 break 6680 end # end choice 6681 6682 break unless _tmp 6683 end 6684 _tmp = true 6685 unless _tmp 6686 self.pos = _save 6687 break 6688 end 6689 _tmp = apply(:_HtmlBlockCloseDd) 6690 unless _tmp 6691 self.pos = _save 6692 end 6693 break 6694 end # end sequence 6695 6696 set_failed_rule :_HtmlBlockDd unless _tmp 6697 return _tmp 6698 end 6699 6700 # HtmlBlockOpenDt = "<" Spnl ("dt" | "DT") Spnl HtmlAttribute* ">" 6701 def _HtmlBlockOpenDt 6702 6703 _save = self.pos 6704 while true # sequence 6705 _tmp = match_string("<") 6706 unless _tmp 6707 self.pos = _save 6708 break 6709 end 6710 _tmp = apply(:_Spnl) 6711 unless _tmp 6712 self.pos = _save 6713 break 6714 end 6715 6716 _save1 = self.pos 6717 while true # choice 6718 _tmp = match_string("dt") 6719 break if _tmp 6720 self.pos = _save1 6721 _tmp = match_string("DT") 6722 break if _tmp 6723 self.pos = _save1 6724 break 6725 end # end choice 6726 6727 unless _tmp 6728 self.pos = _save 6729 break 6730 end 6731 _tmp = apply(:_Spnl) 6732 unless _tmp 6733 self.pos = _save 6734 break 6735 end 6736 while true 6737 _tmp = apply(:_HtmlAttribute) 6738 break unless _tmp 6739 end 6740 _tmp = true 6741 unless _tmp 6742 self.pos = _save 6743 break 6744 end 6745 _tmp = match_string(">") 6746 unless _tmp 6747 self.pos = _save 6748 end 6749 break 6750 end # end sequence 6751 6752 set_failed_rule :_HtmlBlockOpenDt unless _tmp 6753 return _tmp 6754 end 6755 6756 # HtmlBlockCloseDt = "<" Spnl "/" ("dt" | "DT") Spnl ">" 6757 def _HtmlBlockCloseDt 6758 6759 _save = self.pos 6760 while true # sequence 6761 _tmp = match_string("<") 6762 unless _tmp 6763 self.pos = _save 6764 break 6765 end 6766 _tmp = apply(:_Spnl) 6767 unless _tmp 6768 self.pos = _save 6769 break 6770 end 6771 _tmp = match_string("/") 6772 unless _tmp 6773 self.pos = _save 6774 break 6775 end 6776 6777 _save1 = self.pos 6778 while true # choice 6779 _tmp = match_string("dt") 6780 break if _tmp 6781 self.pos = _save1 6782 _tmp = match_string("DT") 6783 break if _tmp 6784 self.pos = _save1 6785 break 6786 end # end choice 6787 6788 unless _tmp 6789 self.pos = _save 6790 break 6791 end 6792 _tmp = apply(:_Spnl) 6793 unless _tmp 6794 self.pos = _save 6795 break 6796 end 6797 _tmp = match_string(">") 6798 unless _tmp 6799 self.pos = _save 6800 end 6801 break 6802 end # end sequence 6803 6804 set_failed_rule :_HtmlBlockCloseDt unless _tmp 6805 return _tmp 6806 end 6807 6808 # HtmlBlockDt = HtmlBlockOpenDt (HtmlBlockDt | !HtmlBlockCloseDt .)* HtmlBlockCloseDt 6809 def _HtmlBlockDt 6810 6811 _save = self.pos 6812 while true # sequence 6813 _tmp = apply(:_HtmlBlockOpenDt) 6814 unless _tmp 6815 self.pos = _save 6816 break 6817 end 6818 while true 6819 6820 _save2 = self.pos 6821 while true # choice 6822 _tmp = apply(:_HtmlBlockDt) 6823 break if _tmp 6824 self.pos = _save2 6825 6826 _save3 = self.pos 6827 while true # sequence 6828 _save4 = self.pos 6829 _tmp = apply(:_HtmlBlockCloseDt) 6830 _tmp = _tmp ? nil : true 6831 self.pos = _save4 6832 unless _tmp 6833 self.pos = _save3 6834 break 6835 end 6836 _tmp = get_byte 6837 unless _tmp 6838 self.pos = _save3 6839 end 6840 break 6841 end # end sequence 6842 6843 break if _tmp 6844 self.pos = _save2 6845 break 6846 end # end choice 6847 6848 break unless _tmp 6849 end 6850 _tmp = true 6851 unless _tmp 6852 self.pos = _save 6853 break 6854 end 6855 _tmp = apply(:_HtmlBlockCloseDt) 6856 unless _tmp 6857 self.pos = _save 6858 end 6859 break 6860 end # end sequence 6861 6862 set_failed_rule :_HtmlBlockDt unless _tmp 6863 return _tmp 6864 end 6865 6866 # HtmlBlockOpenFrameset = "<" Spnl ("frameset" | "FRAMESET") Spnl HtmlAttribute* ">" 6867 def _HtmlBlockOpenFrameset 6868 6869 _save = self.pos 6870 while true # sequence 6871 _tmp = match_string("<") 6872 unless _tmp 6873 self.pos = _save 6874 break 6875 end 6876 _tmp = apply(:_Spnl) 6877 unless _tmp 6878 self.pos = _save 6879 break 6880 end 6881 6882 _save1 = self.pos 6883 while true # choice 6884 _tmp = match_string("frameset") 6885 break if _tmp 6886 self.pos = _save1 6887 _tmp = match_string("FRAMESET") 6888 break if _tmp 6889 self.pos = _save1 6890 break 6891 end # end choice 6892 6893 unless _tmp 6894 self.pos = _save 6895 break 6896 end 6897 _tmp = apply(:_Spnl) 6898 unless _tmp 6899 self.pos = _save 6900 break 6901 end 6902 while true 6903 _tmp = apply(:_HtmlAttribute) 6904 break unless _tmp 6905 end 6906 _tmp = true 6907 unless _tmp 6908 self.pos = _save 6909 break 6910 end 6911 _tmp = match_string(">") 6912 unless _tmp 6913 self.pos = _save 6914 end 6915 break 6916 end # end sequence 6917 6918 set_failed_rule :_HtmlBlockOpenFrameset unless _tmp 6919 return _tmp 6920 end 6921 6922 # HtmlBlockCloseFrameset = "<" Spnl "/" ("frameset" | "FRAMESET") Spnl ">" 6923 def _HtmlBlockCloseFrameset 6924 6925 _save = self.pos 6926 while true # sequence 6927 _tmp = match_string("<") 6928 unless _tmp 6929 self.pos = _save 6930 break 6931 end 6932 _tmp = apply(:_Spnl) 6933 unless _tmp 6934 self.pos = _save 6935 break 6936 end 6937 _tmp = match_string("/") 6938 unless _tmp 6939 self.pos = _save 6940 break 6941 end 6942 6943 _save1 = self.pos 6944 while true # choice 6945 _tmp = match_string("frameset") 6946 break if _tmp 6947 self.pos = _save1 6948 _tmp = match_string("FRAMESET") 6949 break if _tmp 6950 self.pos = _save1 6951 break 6952 end # end choice 6953 6954 unless _tmp 6955 self.pos = _save 6956 break 6957 end 6958 _tmp = apply(:_Spnl) 6959 unless _tmp 6960 self.pos = _save 6961 break 6962 end 6963 _tmp = match_string(">") 6964 unless _tmp 6965 self.pos = _save 6966 end 6967 break 6968 end # end sequence 6969 6970 set_failed_rule :_HtmlBlockCloseFrameset unless _tmp 6971 return _tmp 6972 end 6973 6974 # HtmlBlockFrameset = HtmlBlockOpenFrameset (HtmlBlockFrameset | !HtmlBlockCloseFrameset .)* HtmlBlockCloseFrameset 6975 def _HtmlBlockFrameset 6976 6977 _save = self.pos 6978 while true # sequence 6979 _tmp = apply(:_HtmlBlockOpenFrameset) 6980 unless _tmp 6981 self.pos = _save 6982 break 6983 end 6984 while true 6985 6986 _save2 = self.pos 6987 while true # choice 6988 _tmp = apply(:_HtmlBlockFrameset) 6989 break if _tmp 6990 self.pos = _save2 6991 6992 _save3 = self.pos 6993 while true # sequence 6994 _save4 = self.pos 6995 _tmp = apply(:_HtmlBlockCloseFrameset) 6996 _tmp = _tmp ? nil : true 6997 self.pos = _save4 6998 unless _tmp 6999 self.pos = _save3 7000 break 7001 end 7002 _tmp = get_byte 7003 unless _tmp 7004 self.pos = _save3 7005 end 7006 break 7007 end # end sequence 7008 7009 break if _tmp 7010 self.pos = _save2 7011 break 7012 end # end choice 7013 7014 break unless _tmp 7015 end 7016 _tmp = true 7017 unless _tmp 7018 self.pos = _save 7019 break 7020 end 7021 _tmp = apply(:_HtmlBlockCloseFrameset) 7022 unless _tmp 7023 self.pos = _save 7024 end 7025 break 7026 end # end sequence 7027 7028 set_failed_rule :_HtmlBlockFrameset unless _tmp 7029 return _tmp 7030 end 7031 7032 # HtmlBlockOpenLi = "<" Spnl ("li" | "LI") Spnl HtmlAttribute* ">" 7033 def _HtmlBlockOpenLi 7034 7035 _save = self.pos 7036 while true # sequence 7037 _tmp = match_string("<") 7038 unless _tmp 7039 self.pos = _save 7040 break 7041 end 7042 _tmp = apply(:_Spnl) 7043 unless _tmp 7044 self.pos = _save 7045 break 7046 end 7047 7048 _save1 = self.pos 7049 while true # choice 7050 _tmp = match_string("li") 7051 break if _tmp 7052 self.pos = _save1 7053 _tmp = match_string("LI") 7054 break if _tmp 7055 self.pos = _save1 7056 break 7057 end # end choice 7058 7059 unless _tmp 7060 self.pos = _save 7061 break 7062 end 7063 _tmp = apply(:_Spnl) 7064 unless _tmp 7065 self.pos = _save 7066 break 7067 end 7068 while true 7069 _tmp = apply(:_HtmlAttribute) 7070 break unless _tmp 7071 end 7072 _tmp = true 7073 unless _tmp 7074 self.pos = _save 7075 break 7076 end 7077 _tmp = match_string(">") 7078 unless _tmp 7079 self.pos = _save 7080 end 7081 break 7082 end # end sequence 7083 7084 set_failed_rule :_HtmlBlockOpenLi unless _tmp 7085 return _tmp 7086 end 7087 7088 # HtmlBlockCloseLi = "<" Spnl "/" ("li" | "LI") Spnl ">" 7089 def _HtmlBlockCloseLi 7090 7091 _save = self.pos 7092 while true # sequence 7093 _tmp = match_string("<") 7094 unless _tmp 7095 self.pos = _save 7096 break 7097 end 7098 _tmp = apply(:_Spnl) 7099 unless _tmp 7100 self.pos = _save 7101 break 7102 end 7103 _tmp = match_string("/") 7104 unless _tmp 7105 self.pos = _save 7106 break 7107 end 7108 7109 _save1 = self.pos 7110 while true # choice 7111 _tmp = match_string("li") 7112 break if _tmp 7113 self.pos = _save1 7114 _tmp = match_string("LI") 7115 break if _tmp 7116 self.pos = _save1 7117 break 7118 end # end choice 7119 7120 unless _tmp 7121 self.pos = _save 7122 break 7123 end 7124 _tmp = apply(:_Spnl) 7125 unless _tmp 7126 self.pos = _save 7127 break 7128 end 7129 _tmp = match_string(">") 7130 unless _tmp 7131 self.pos = _save 7132 end 7133 break 7134 end # end sequence 7135 7136 set_failed_rule :_HtmlBlockCloseLi unless _tmp 7137 return _tmp 7138 end 7139 7140 # HtmlBlockLi = HtmlBlockOpenLi (HtmlBlockLi | !HtmlBlockCloseLi .)* HtmlBlockCloseLi 7141 def _HtmlBlockLi 7142 7143 _save = self.pos 7144 while true # sequence 7145 _tmp = apply(:_HtmlBlockOpenLi) 7146 unless _tmp 7147 self.pos = _save 7148 break 7149 end 7150 while true 7151 7152 _save2 = self.pos 7153 while true # choice 7154 _tmp = apply(:_HtmlBlockLi) 7155 break if _tmp 7156 self.pos = _save2 7157 7158 _save3 = self.pos 7159 while true # sequence 7160 _save4 = self.pos 7161 _tmp = apply(:_HtmlBlockCloseLi) 7162 _tmp = _tmp ? nil : true 7163 self.pos = _save4 7164 unless _tmp 7165 self.pos = _save3 7166 break 7167 end 7168 _tmp = get_byte 7169 unless _tmp 7170 self.pos = _save3 7171 end 7172 break 7173 end # end sequence 7174 7175 break if _tmp 7176 self.pos = _save2 7177 break 7178 end # end choice 7179 7180 break unless _tmp 7181 end 7182 _tmp = true 7183 unless _tmp 7184 self.pos = _save 7185 break 7186 end 7187 _tmp = apply(:_HtmlBlockCloseLi) 7188 unless _tmp 7189 self.pos = _save 7190 end 7191 break 7192 end # end sequence 7193 7194 set_failed_rule :_HtmlBlockLi unless _tmp 7195 return _tmp 7196 end 7197 7198 # HtmlBlockOpenTbody = "<" Spnl ("tbody" | "TBODY") Spnl HtmlAttribute* ">" 7199 def _HtmlBlockOpenTbody 7200 7201 _save = self.pos 7202 while true # sequence 7203 _tmp = match_string("<") 7204 unless _tmp 7205 self.pos = _save 7206 break 7207 end 7208 _tmp = apply(:_Spnl) 7209 unless _tmp 7210 self.pos = _save 7211 break 7212 end 7213 7214 _save1 = self.pos 7215 while true # choice 7216 _tmp = match_string("tbody") 7217 break if _tmp 7218 self.pos = _save1 7219 _tmp = match_string("TBODY") 7220 break if _tmp 7221 self.pos = _save1 7222 break 7223 end # end choice 7224 7225 unless _tmp 7226 self.pos = _save 7227 break 7228 end 7229 _tmp = apply(:_Spnl) 7230 unless _tmp 7231 self.pos = _save 7232 break 7233 end 7234 while true 7235 _tmp = apply(:_HtmlAttribute) 7236 break unless _tmp 7237 end 7238 _tmp = true 7239 unless _tmp 7240 self.pos = _save 7241 break 7242 end 7243 _tmp = match_string(">") 7244 unless _tmp 7245 self.pos = _save 7246 end 7247 break 7248 end # end sequence 7249 7250 set_failed_rule :_HtmlBlockOpenTbody unless _tmp 7251 return _tmp 7252 end 7253 7254 # HtmlBlockCloseTbody = "<" Spnl "/" ("tbody" | "TBODY") Spnl ">" 7255 def _HtmlBlockCloseTbody 7256 7257 _save = self.pos 7258 while true # sequence 7259 _tmp = match_string("<") 7260 unless _tmp 7261 self.pos = _save 7262 break 7263 end 7264 _tmp = apply(:_Spnl) 7265 unless _tmp 7266 self.pos = _save 7267 break 7268 end 7269 _tmp = match_string("/") 7270 unless _tmp 7271 self.pos = _save 7272 break 7273 end 7274 7275 _save1 = self.pos 7276 while true # choice 7277 _tmp = match_string("tbody") 7278 break if _tmp 7279 self.pos = _save1 7280 _tmp = match_string("TBODY") 7281 break if _tmp 7282 self.pos = _save1 7283 break 7284 end # end choice 7285 7286 unless _tmp 7287 self.pos = _save 7288 break 7289 end 7290 _tmp = apply(:_Spnl) 7291 unless _tmp 7292 self.pos = _save 7293 break 7294 end 7295 _tmp = match_string(">") 7296 unless _tmp 7297 self.pos = _save 7298 end 7299 break 7300 end # end sequence 7301 7302 set_failed_rule :_HtmlBlockCloseTbody unless _tmp 7303 return _tmp 7304 end 7305 7306 # HtmlBlockTbody = HtmlBlockOpenTbody (HtmlBlockTbody | !HtmlBlockCloseTbody .)* HtmlBlockCloseTbody 7307 def _HtmlBlockTbody 7308 7309 _save = self.pos 7310 while true # sequence 7311 _tmp = apply(:_HtmlBlockOpenTbody) 7312 unless _tmp 7313 self.pos = _save 7314 break 7315 end 7316 while true 7317 7318 _save2 = self.pos 7319 while true # choice 7320 _tmp = apply(:_HtmlBlockTbody) 7321 break if _tmp 7322 self.pos = _save2 7323 7324 _save3 = self.pos 7325 while true # sequence 7326 _save4 = self.pos 7327 _tmp = apply(:_HtmlBlockCloseTbody) 7328 _tmp = _tmp ? nil : true 7329 self.pos = _save4 7330 unless _tmp 7331 self.pos = _save3 7332 break 7333 end 7334 _tmp = get_byte 7335 unless _tmp 7336 self.pos = _save3 7337 end 7338 break 7339 end # end sequence 7340 7341 break if _tmp 7342 self.pos = _save2 7343 break 7344 end # end choice 7345 7346 break unless _tmp 7347 end 7348 _tmp = true 7349 unless _tmp 7350 self.pos = _save 7351 break 7352 end 7353 _tmp = apply(:_HtmlBlockCloseTbody) 7354 unless _tmp 7355 self.pos = _save 7356 end 7357 break 7358 end # end sequence 7359 7360 set_failed_rule :_HtmlBlockTbody unless _tmp 7361 return _tmp 7362 end 7363 7364 # HtmlBlockOpenTd = "<" Spnl ("td" | "TD") Spnl HtmlAttribute* ">" 7365 def _HtmlBlockOpenTd 7366 7367 _save = self.pos 7368 while true # sequence 7369 _tmp = match_string("<") 7370 unless _tmp 7371 self.pos = _save 7372 break 7373 end 7374 _tmp = apply(:_Spnl) 7375 unless _tmp 7376 self.pos = _save 7377 break 7378 end 7379 7380 _save1 = self.pos 7381 while true # choice 7382 _tmp = match_string("td") 7383 break if _tmp 7384 self.pos = _save1 7385 _tmp = match_string("TD") 7386 break if _tmp 7387 self.pos = _save1 7388 break 7389 end # end choice 7390 7391 unless _tmp 7392 self.pos = _save 7393 break 7394 end 7395 _tmp = apply(:_Spnl) 7396 unless _tmp 7397 self.pos = _save 7398 break 7399 end 7400 while true 7401 _tmp = apply(:_HtmlAttribute) 7402 break unless _tmp 7403 end 7404 _tmp = true 7405 unless _tmp 7406 self.pos = _save 7407 break 7408 end 7409 _tmp = match_string(">") 7410 unless _tmp 7411 self.pos = _save 7412 end 7413 break 7414 end # end sequence 7415 7416 set_failed_rule :_HtmlBlockOpenTd unless _tmp 7417 return _tmp 7418 end 7419 7420 # HtmlBlockCloseTd = "<" Spnl "/" ("td" | "TD") Spnl ">" 7421 def _HtmlBlockCloseTd 7422 7423 _save = self.pos 7424 while true # sequence 7425 _tmp = match_string("<") 7426 unless _tmp 7427 self.pos = _save 7428 break 7429 end 7430 _tmp = apply(:_Spnl) 7431 unless _tmp 7432 self.pos = _save 7433 break 7434 end 7435 _tmp = match_string("/") 7436 unless _tmp 7437 self.pos = _save 7438 break 7439 end 7440 7441 _save1 = self.pos 7442 while true # choice 7443 _tmp = match_string("td") 7444 break if _tmp 7445 self.pos = _save1 7446 _tmp = match_string("TD") 7447 break if _tmp 7448 self.pos = _save1 7449 break 7450 end # end choice 7451 7452 unless _tmp 7453 self.pos = _save 7454 break 7455 end 7456 _tmp = apply(:_Spnl) 7457 unless _tmp 7458 self.pos = _save 7459 break 7460 end 7461 _tmp = match_string(">") 7462 unless _tmp 7463 self.pos = _save 7464 end 7465 break 7466 end # end sequence 7467 7468 set_failed_rule :_HtmlBlockCloseTd unless _tmp 7469 return _tmp 7470 end 7471 7472 # HtmlBlockTd = HtmlBlockOpenTd (HtmlBlockTd | !HtmlBlockCloseTd .)* HtmlBlockCloseTd 7473 def _HtmlBlockTd 7474 7475 _save = self.pos 7476 while true # sequence 7477 _tmp = apply(:_HtmlBlockOpenTd) 7478 unless _tmp 7479 self.pos = _save 7480 break 7481 end 7482 while true 7483 7484 _save2 = self.pos 7485 while true # choice 7486 _tmp = apply(:_HtmlBlockTd) 7487 break if _tmp 7488 self.pos = _save2 7489 7490 _save3 = self.pos 7491 while true # sequence 7492 _save4 = self.pos 7493 _tmp = apply(:_HtmlBlockCloseTd) 7494 _tmp = _tmp ? nil : true 7495 self.pos = _save4 7496 unless _tmp 7497 self.pos = _save3 7498 break 7499 end 7500 _tmp = get_byte 7501 unless _tmp 7502 self.pos = _save3 7503 end 7504 break 7505 end # end sequence 7506 7507 break if _tmp 7508 self.pos = _save2 7509 break 7510 end # end choice 7511 7512 break unless _tmp 7513 end 7514 _tmp = true 7515 unless _tmp 7516 self.pos = _save 7517 break 7518 end 7519 _tmp = apply(:_HtmlBlockCloseTd) 7520 unless _tmp 7521 self.pos = _save 7522 end 7523 break 7524 end # end sequence 7525 7526 set_failed_rule :_HtmlBlockTd unless _tmp 7527 return _tmp 7528 end 7529 7530 # HtmlBlockOpenTfoot = "<" Spnl ("tfoot" | "TFOOT") Spnl HtmlAttribute* ">" 7531 def _HtmlBlockOpenTfoot 7532 7533 _save = self.pos 7534 while true # sequence 7535 _tmp = match_string("<") 7536 unless _tmp 7537 self.pos = _save 7538 break 7539 end 7540 _tmp = apply(:_Spnl) 7541 unless _tmp 7542 self.pos = _save 7543 break 7544 end 7545 7546 _save1 = self.pos 7547 while true # choice 7548 _tmp = match_string("tfoot") 7549 break if _tmp 7550 self.pos = _save1 7551 _tmp = match_string("TFOOT") 7552 break if _tmp 7553 self.pos = _save1 7554 break 7555 end # end choice 7556 7557 unless _tmp 7558 self.pos = _save 7559 break 7560 end 7561 _tmp = apply(:_Spnl) 7562 unless _tmp 7563 self.pos = _save 7564 break 7565 end 7566 while true 7567 _tmp = apply(:_HtmlAttribute) 7568 break unless _tmp 7569 end 7570 _tmp = true 7571 unless _tmp 7572 self.pos = _save 7573 break 7574 end 7575 _tmp = match_string(">") 7576 unless _tmp 7577 self.pos = _save 7578 end 7579 break 7580 end # end sequence 7581 7582 set_failed_rule :_HtmlBlockOpenTfoot unless _tmp 7583 return _tmp 7584 end 7585 7586 # HtmlBlockCloseTfoot = "<" Spnl "/" ("tfoot" | "TFOOT") Spnl ">" 7587 def _HtmlBlockCloseTfoot 7588 7589 _save = self.pos 7590 while true # sequence 7591 _tmp = match_string("<") 7592 unless _tmp 7593 self.pos = _save 7594 break 7595 end 7596 _tmp = apply(:_Spnl) 7597 unless _tmp 7598 self.pos = _save 7599 break 7600 end 7601 _tmp = match_string("/") 7602 unless _tmp 7603 self.pos = _save 7604 break 7605 end 7606 7607 _save1 = self.pos 7608 while true # choice 7609 _tmp = match_string("tfoot") 7610 break if _tmp 7611 self.pos = _save1 7612 _tmp = match_string("TFOOT") 7613 break if _tmp 7614 self.pos = _save1 7615 break 7616 end # end choice 7617 7618 unless _tmp 7619 self.pos = _save 7620 break 7621 end 7622 _tmp = apply(:_Spnl) 7623 unless _tmp 7624 self.pos = _save 7625 break 7626 end 7627 _tmp = match_string(">") 7628 unless _tmp 7629 self.pos = _save 7630 end 7631 break 7632 end # end sequence 7633 7634 set_failed_rule :_HtmlBlockCloseTfoot unless _tmp 7635 return _tmp 7636 end 7637 7638 # HtmlBlockTfoot = HtmlBlockOpenTfoot (HtmlBlockTfoot | !HtmlBlockCloseTfoot .)* HtmlBlockCloseTfoot 7639 def _HtmlBlockTfoot 7640 7641 _save = self.pos 7642 while true # sequence 7643 _tmp = apply(:_HtmlBlockOpenTfoot) 7644 unless _tmp 7645 self.pos = _save 7646 break 7647 end 7648 while true 7649 7650 _save2 = self.pos 7651 while true # choice 7652 _tmp = apply(:_HtmlBlockTfoot) 7653 break if _tmp 7654 self.pos = _save2 7655 7656 _save3 = self.pos 7657 while true # sequence 7658 _save4 = self.pos 7659 _tmp = apply(:_HtmlBlockCloseTfoot) 7660 _tmp = _tmp ? nil : true 7661 self.pos = _save4 7662 unless _tmp 7663 self.pos = _save3 7664 break 7665 end 7666 _tmp = get_byte 7667 unless _tmp 7668 self.pos = _save3 7669 end 7670 break 7671 end # end sequence 7672 7673 break if _tmp 7674 self.pos = _save2 7675 break 7676 end # end choice 7677 7678 break unless _tmp 7679 end 7680 _tmp = true 7681 unless _tmp 7682 self.pos = _save 7683 break 7684 end 7685 _tmp = apply(:_HtmlBlockCloseTfoot) 7686 unless _tmp 7687 self.pos = _save 7688 end 7689 break 7690 end # end sequence 7691 7692 set_failed_rule :_HtmlBlockTfoot unless _tmp 7693 return _tmp 7694 end 7695 7696 # HtmlBlockOpenTh = "<" Spnl ("th" | "TH") Spnl HtmlAttribute* ">" 7697 def _HtmlBlockOpenTh 7698 7699 _save = self.pos 7700 while true # sequence 7701 _tmp = match_string("<") 7702 unless _tmp 7703 self.pos = _save 7704 break 7705 end 7706 _tmp = apply(:_Spnl) 7707 unless _tmp 7708 self.pos = _save 7709 break 7710 end 7711 7712 _save1 = self.pos 7713 while true # choice 7714 _tmp = match_string("th") 7715 break if _tmp 7716 self.pos = _save1 7717 _tmp = match_string("TH") 7718 break if _tmp 7719 self.pos = _save1 7720 break 7721 end # end choice 7722 7723 unless _tmp 7724 self.pos = _save 7725 break 7726 end 7727 _tmp = apply(:_Spnl) 7728 unless _tmp 7729 self.pos = _save 7730 break 7731 end 7732 while true 7733 _tmp = apply(:_HtmlAttribute) 7734 break unless _tmp 7735 end 7736 _tmp = true 7737 unless _tmp 7738 self.pos = _save 7739 break 7740 end 7741 _tmp = match_string(">") 7742 unless _tmp 7743 self.pos = _save 7744 end 7745 break 7746 end # end sequence 7747 7748 set_failed_rule :_HtmlBlockOpenTh unless _tmp 7749 return _tmp 7750 end 7751 7752 # HtmlBlockCloseTh = "<" Spnl "/" ("th" | "TH") Spnl ">" 7753 def _HtmlBlockCloseTh 7754 7755 _save = self.pos 7756 while true # sequence 7757 _tmp = match_string("<") 7758 unless _tmp 7759 self.pos = _save 7760 break 7761 end 7762 _tmp = apply(:_Spnl) 7763 unless _tmp 7764 self.pos = _save 7765 break 7766 end 7767 _tmp = match_string("/") 7768 unless _tmp 7769 self.pos = _save 7770 break 7771 end 7772 7773 _save1 = self.pos 7774 while true # choice 7775 _tmp = match_string("th") 7776 break if _tmp 7777 self.pos = _save1 7778 _tmp = match_string("TH") 7779 break if _tmp 7780 self.pos = _save1 7781 break 7782 end # end choice 7783 7784 unless _tmp 7785 self.pos = _save 7786 break 7787 end 7788 _tmp = apply(:_Spnl) 7789 unless _tmp 7790 self.pos = _save 7791 break 7792 end 7793 _tmp = match_string(">") 7794 unless _tmp 7795 self.pos = _save 7796 end 7797 break 7798 end # end sequence 7799 7800 set_failed_rule :_HtmlBlockCloseTh unless _tmp 7801 return _tmp 7802 end 7803 7804 # HtmlBlockTh = HtmlBlockOpenTh (HtmlBlockTh | !HtmlBlockCloseTh .)* HtmlBlockCloseTh 7805 def _HtmlBlockTh 7806 7807 _save = self.pos 7808 while true # sequence 7809 _tmp = apply(:_HtmlBlockOpenTh) 7810 unless _tmp 7811 self.pos = _save 7812 break 7813 end 7814 while true 7815 7816 _save2 = self.pos 7817 while true # choice 7818 _tmp = apply(:_HtmlBlockTh) 7819 break if _tmp 7820 self.pos = _save2 7821 7822 _save3 = self.pos 7823 while true # sequence 7824 _save4 = self.pos 7825 _tmp = apply(:_HtmlBlockCloseTh) 7826 _tmp = _tmp ? nil : true 7827 self.pos = _save4 7828 unless _tmp 7829 self.pos = _save3 7830 break 7831 end 7832 _tmp = get_byte 7833 unless _tmp 7834 self.pos = _save3 7835 end 7836 break 7837 end # end sequence 7838 7839 break if _tmp 7840 self.pos = _save2 7841 break 7842 end # end choice 7843 7844 break unless _tmp 7845 end 7846 _tmp = true 7847 unless _tmp 7848 self.pos = _save 7849 break 7850 end 7851 _tmp = apply(:_HtmlBlockCloseTh) 7852 unless _tmp 7853 self.pos = _save 7854 end 7855 break 7856 end # end sequence 7857 7858 set_failed_rule :_HtmlBlockTh unless _tmp 7859 return _tmp 7860 end 7861 7862 # HtmlBlockOpenThead = "<" Spnl ("thead" | "THEAD") Spnl HtmlAttribute* ">" 7863 def _HtmlBlockOpenThead 7864 7865 _save = self.pos 7866 while true # sequence 7867 _tmp = match_string("<") 7868 unless _tmp 7869 self.pos = _save 7870 break 7871 end 7872 _tmp = apply(:_Spnl) 7873 unless _tmp 7874 self.pos = _save 7875 break 7876 end 7877 7878 _save1 = self.pos 7879 while true # choice 7880 _tmp = match_string("thead") 7881 break if _tmp 7882 self.pos = _save1 7883 _tmp = match_string("THEAD") 7884 break if _tmp 7885 self.pos = _save1 7886 break 7887 end # end choice 7888 7889 unless _tmp 7890 self.pos = _save 7891 break 7892 end 7893 _tmp = apply(:_Spnl) 7894 unless _tmp 7895 self.pos = _save 7896 break 7897 end 7898 while true 7899 _tmp = apply(:_HtmlAttribute) 7900 break unless _tmp 7901 end 7902 _tmp = true 7903 unless _tmp 7904 self.pos = _save 7905 break 7906 end 7907 _tmp = match_string(">") 7908 unless _tmp 7909 self.pos = _save 7910 end 7911 break 7912 end # end sequence 7913 7914 set_failed_rule :_HtmlBlockOpenThead unless _tmp 7915 return _tmp 7916 end 7917 7918 # HtmlBlockCloseThead = "<" Spnl "/" ("thead" | "THEAD") Spnl ">" 7919 def _HtmlBlockCloseThead 7920 7921 _save = self.pos 7922 while true # sequence 7923 _tmp = match_string("<") 7924 unless _tmp 7925 self.pos = _save 7926 break 7927 end 7928 _tmp = apply(:_Spnl) 7929 unless _tmp 7930 self.pos = _save 7931 break 7932 end 7933 _tmp = match_string("/") 7934 unless _tmp 7935 self.pos = _save 7936 break 7937 end 7938 7939 _save1 = self.pos 7940 while true # choice 7941 _tmp = match_string("thead") 7942 break if _tmp 7943 self.pos = _save1 7944 _tmp = match_string("THEAD") 7945 break if _tmp 7946 self.pos = _save1 7947 break 7948 end # end choice 7949 7950 unless _tmp 7951 self.pos = _save 7952 break 7953 end 7954 _tmp = apply(:_Spnl) 7955 unless _tmp 7956 self.pos = _save 7957 break 7958 end 7959 _tmp = match_string(">") 7960 unless _tmp 7961 self.pos = _save 7962 end 7963 break 7964 end # end sequence 7965 7966 set_failed_rule :_HtmlBlockCloseThead unless _tmp 7967 return _tmp 7968 end 7969 7970 # HtmlBlockThead = HtmlBlockOpenThead (HtmlBlockThead | !HtmlBlockCloseThead .)* HtmlBlockCloseThead 7971 def _HtmlBlockThead 7972 7973 _save = self.pos 7974 while true # sequence 7975 _tmp = apply(:_HtmlBlockOpenThead) 7976 unless _tmp 7977 self.pos = _save 7978 break 7979 end 7980 while true 7981 7982 _save2 = self.pos 7983 while true # choice 7984 _tmp = apply(:_HtmlBlockThead) 7985 break if _tmp 7986 self.pos = _save2 7987 7988 _save3 = self.pos 7989 while true # sequence 7990 _save4 = self.pos 7991 _tmp = apply(:_HtmlBlockCloseThead) 7992 _tmp = _tmp ? nil : true 7993 self.pos = _save4 7994 unless _tmp 7995 self.pos = _save3 7996 break 7997 end 7998 _tmp = get_byte 7999 unless _tmp 8000 self.pos = _save3 8001 end 8002 break 8003 end # end sequence 8004 8005 break if _tmp 8006 self.pos = _save2 8007 break 8008 end # end choice 8009 8010 break unless _tmp 8011 end 8012 _tmp = true 8013 unless _tmp 8014 self.pos = _save 8015 break 8016 end 8017 _tmp = apply(:_HtmlBlockCloseThead) 8018 unless _tmp 8019 self.pos = _save 8020 end 8021 break 8022 end # end sequence 8023 8024 set_failed_rule :_HtmlBlockThead unless _tmp 8025 return _tmp 8026 end 8027 8028 # HtmlBlockOpenTr = "<" Spnl ("tr" | "TR") Spnl HtmlAttribute* ">" 8029 def _HtmlBlockOpenTr 8030 8031 _save = self.pos 8032 while true # sequence 8033 _tmp = match_string("<") 8034 unless _tmp 8035 self.pos = _save 8036 break 8037 end 8038 _tmp = apply(:_Spnl) 8039 unless _tmp 8040 self.pos = _save 8041 break 8042 end 8043 8044 _save1 = self.pos 8045 while true # choice 8046 _tmp = match_string("tr") 8047 break if _tmp 8048 self.pos = _save1 8049 _tmp = match_string("TR") 8050 break if _tmp 8051 self.pos = _save1 8052 break 8053 end # end choice 8054 8055 unless _tmp 8056 self.pos = _save 8057 break 8058 end 8059 _tmp = apply(:_Spnl) 8060 unless _tmp 8061 self.pos = _save 8062 break 8063 end 8064 while true 8065 _tmp = apply(:_HtmlAttribute) 8066 break unless _tmp 8067 end 8068 _tmp = true 8069 unless _tmp 8070 self.pos = _save 8071 break 8072 end 8073 _tmp = match_string(">") 8074 unless _tmp 8075 self.pos = _save 8076 end 8077 break 8078 end # end sequence 8079 8080 set_failed_rule :_HtmlBlockOpenTr unless _tmp 8081 return _tmp 8082 end 8083 8084 # HtmlBlockCloseTr = "<" Spnl "/" ("tr" | "TR") Spnl ">" 8085 def _HtmlBlockCloseTr 8086 8087 _save = self.pos 8088 while true # sequence 8089 _tmp = match_string("<") 8090 unless _tmp 8091 self.pos = _save 8092 break 8093 end 8094 _tmp = apply(:_Spnl) 8095 unless _tmp 8096 self.pos = _save 8097 break 8098 end 8099 _tmp = match_string("/") 8100 unless _tmp 8101 self.pos = _save 8102 break 8103 end 8104 8105 _save1 = self.pos 8106 while true # choice 8107 _tmp = match_string("tr") 8108 break if _tmp 8109 self.pos = _save1 8110 _tmp = match_string("TR") 8111 break if _tmp 8112 self.pos = _save1 8113 break 8114 end # end choice 8115 8116 unless _tmp 8117 self.pos = _save 8118 break 8119 end 8120 _tmp = apply(:_Spnl) 8121 unless _tmp 8122 self.pos = _save 8123 break 8124 end 8125 _tmp = match_string(">") 8126 unless _tmp 8127 self.pos = _save 8128 end 8129 break 8130 end # end sequence 8131 8132 set_failed_rule :_HtmlBlockCloseTr unless _tmp 8133 return _tmp 8134 end 8135 8136 # HtmlBlockTr = HtmlBlockOpenTr (HtmlBlockTr | !HtmlBlockCloseTr .)* HtmlBlockCloseTr 8137 def _HtmlBlockTr 8138 8139 _save = self.pos 8140 while true # sequence 8141 _tmp = apply(:_HtmlBlockOpenTr) 8142 unless _tmp 8143 self.pos = _save 8144 break 8145 end 8146 while true 8147 8148 _save2 = self.pos 8149 while true # choice 8150 _tmp = apply(:_HtmlBlockTr) 8151 break if _tmp 8152 self.pos = _save2 8153 8154 _save3 = self.pos 8155 while true # sequence 8156 _save4 = self.pos 8157 _tmp = apply(:_HtmlBlockCloseTr) 8158 _tmp = _tmp ? nil : true 8159 self.pos = _save4 8160 unless _tmp 8161 self.pos = _save3 8162 break 8163 end 8164 _tmp = get_byte 8165 unless _tmp 8166 self.pos = _save3 8167 end 8168 break 8169 end # end sequence 8170 8171 break if _tmp 8172 self.pos = _save2 8173 break 8174 end # end choice 8175 8176 break unless _tmp 8177 end 8178 _tmp = true 8179 unless _tmp 8180 self.pos = _save 8181 break 8182 end 8183 _tmp = apply(:_HtmlBlockCloseTr) 8184 unless _tmp 8185 self.pos = _save 8186 end 8187 break 8188 end # end sequence 8189 8190 set_failed_rule :_HtmlBlockTr unless _tmp 8191 return _tmp 8192 end 8193 8194 # HtmlBlockOpenScript = "<" Spnl ("script" | "SCRIPT") Spnl HtmlAttribute* ">" 8195 def _HtmlBlockOpenScript 8196 8197 _save = self.pos 8198 while true # sequence 8199 _tmp = match_string("<") 8200 unless _tmp 8201 self.pos = _save 8202 break 8203 end 8204 _tmp = apply(:_Spnl) 8205 unless _tmp 8206 self.pos = _save 8207 break 8208 end 8209 8210 _save1 = self.pos 8211 while true # choice 8212 _tmp = match_string("script") 8213 break if _tmp 8214 self.pos = _save1 8215 _tmp = match_string("SCRIPT") 8216 break if _tmp 8217 self.pos = _save1 8218 break 8219 end # end choice 8220 8221 unless _tmp 8222 self.pos = _save 8223 break 8224 end 8225 _tmp = apply(:_Spnl) 8226 unless _tmp 8227 self.pos = _save 8228 break 8229 end 8230 while true 8231 _tmp = apply(:_HtmlAttribute) 8232 break unless _tmp 8233 end 8234 _tmp = true 8235 unless _tmp 8236 self.pos = _save 8237 break 8238 end 8239 _tmp = match_string(">") 8240 unless _tmp 8241 self.pos = _save 8242 end 8243 break 8244 end # end sequence 8245 8246 set_failed_rule :_HtmlBlockOpenScript unless _tmp 8247 return _tmp 8248 end 8249 8250 # HtmlBlockCloseScript = "<" Spnl "/" ("script" | "SCRIPT") Spnl ">" 8251 def _HtmlBlockCloseScript 8252 8253 _save = self.pos 8254 while true # sequence 8255 _tmp = match_string("<") 8256 unless _tmp 8257 self.pos = _save 8258 break 8259 end 8260 _tmp = apply(:_Spnl) 8261 unless _tmp 8262 self.pos = _save 8263 break 8264 end 8265 _tmp = match_string("/") 8266 unless _tmp 8267 self.pos = _save 8268 break 8269 end 8270 8271 _save1 = self.pos 8272 while true # choice 8273 _tmp = match_string("script") 8274 break if _tmp 8275 self.pos = _save1 8276 _tmp = match_string("SCRIPT") 8277 break if _tmp 8278 self.pos = _save1 8279 break 8280 end # end choice 8281 8282 unless _tmp 8283 self.pos = _save 8284 break 8285 end 8286 _tmp = apply(:_Spnl) 8287 unless _tmp 8288 self.pos = _save 8289 break 8290 end 8291 _tmp = match_string(">") 8292 unless _tmp 8293 self.pos = _save 8294 end 8295 break 8296 end # end sequence 8297 8298 set_failed_rule :_HtmlBlockCloseScript unless _tmp 8299 return _tmp 8300 end 8301 8302 # HtmlBlockScript = HtmlBlockOpenScript (!HtmlBlockCloseScript .)* HtmlBlockCloseScript 8303 def _HtmlBlockScript 8304 8305 _save = self.pos 8306 while true # sequence 8307 _tmp = apply(:_HtmlBlockOpenScript) 8308 unless _tmp 8309 self.pos = _save 8310 break 8311 end 8312 while true 8313 8314 _save2 = self.pos 8315 while true # sequence 8316 _save3 = self.pos 8317 _tmp = apply(:_HtmlBlockCloseScript) 8318 _tmp = _tmp ? nil : true 8319 self.pos = _save3 8320 unless _tmp 8321 self.pos = _save2 8322 break 8323 end 8324 _tmp = get_byte 8325 unless _tmp 8326 self.pos = _save2 8327 end 8328 break 8329 end # end sequence 8330 8331 break unless _tmp 8332 end 8333 _tmp = true 8334 unless _tmp 8335 self.pos = _save 8336 break 8337 end 8338 _tmp = apply(:_HtmlBlockCloseScript) 8339 unless _tmp 8340 self.pos = _save 8341 end 8342 break 8343 end # end sequence 8344 8345 set_failed_rule :_HtmlBlockScript unless _tmp 8346 return _tmp 8347 end 8348 8349 # HtmlBlockInTags = (HtmlBlockAddress | HtmlBlockBlockquote | HtmlBlockCenter | HtmlBlockDir | HtmlBlockDiv | HtmlBlockDl | HtmlBlockFieldset | HtmlBlockForm | HtmlBlockH1 | HtmlBlockH2 | HtmlBlockH3 | HtmlBlockH4 | HtmlBlockH5 | HtmlBlockH6 | HtmlBlockMenu | HtmlBlockNoframes | HtmlBlockNoscript | HtmlBlockOl | HtmlBlockP | HtmlBlockPre | HtmlBlockTable | HtmlBlockUl | HtmlBlockDd | HtmlBlockDt | HtmlBlockFrameset | HtmlBlockLi | HtmlBlockTbody | HtmlBlockTd | HtmlBlockTfoot | HtmlBlockTh | HtmlBlockThead | HtmlBlockTr | HtmlBlockScript) 8350 def _HtmlBlockInTags 8351 8352 _save = self.pos 8353 while true # choice 8354 _tmp = apply(:_HtmlBlockAddress) 8355 break if _tmp 8356 self.pos = _save 8357 _tmp = apply(:_HtmlBlockBlockquote) 8358 break if _tmp 8359 self.pos = _save 8360 _tmp = apply(:_HtmlBlockCenter) 8361 break if _tmp 8362 self.pos = _save 8363 _tmp = apply(:_HtmlBlockDir) 8364 break if _tmp 8365 self.pos = _save 8366 _tmp = apply(:_HtmlBlockDiv) 8367 break if _tmp 8368 self.pos = _save 8369 _tmp = apply(:_HtmlBlockDl) 8370 break if _tmp 8371 self.pos = _save 8372 _tmp = apply(:_HtmlBlockFieldset) 8373 break if _tmp 8374 self.pos = _save 8375 _tmp = apply(:_HtmlBlockForm) 8376 break if _tmp 8377 self.pos = _save 8378 _tmp = apply(:_HtmlBlockH1) 8379 break if _tmp 8380 self.pos = _save 8381 _tmp = apply(:_HtmlBlockH2) 8382 break if _tmp 8383 self.pos = _save 8384 _tmp = apply(:_HtmlBlockH3) 8385 break if _tmp 8386 self.pos = _save 8387 _tmp = apply(:_HtmlBlockH4) 8388 break if _tmp 8389 self.pos = _save 8390 _tmp = apply(:_HtmlBlockH5) 8391 break if _tmp 8392 self.pos = _save 8393 _tmp = apply(:_HtmlBlockH6) 8394 break if _tmp 8395 self.pos = _save 8396 _tmp = apply(:_HtmlBlockMenu) 8397 break if _tmp 8398 self.pos = _save 8399 _tmp = apply(:_HtmlBlockNoframes) 8400 break if _tmp 8401 self.pos = _save 8402 _tmp = apply(:_HtmlBlockNoscript) 8403 break if _tmp 8404 self.pos = _save 8405 _tmp = apply(:_HtmlBlockOl) 8406 break if _tmp 8407 self.pos = _save 8408 _tmp = apply(:_HtmlBlockP) 8409 break if _tmp 8410 self.pos = _save 8411 _tmp = apply(:_HtmlBlockPre) 8412 break if _tmp 8413 self.pos = _save 8414 _tmp = apply(:_HtmlBlockTable) 8415 break if _tmp 8416 self.pos = _save 8417 _tmp = apply(:_HtmlBlockUl) 8418 break if _tmp 8419 self.pos = _save 8420 _tmp = apply(:_HtmlBlockDd) 8421 break if _tmp 8422 self.pos = _save 8423 _tmp = apply(:_HtmlBlockDt) 8424 break if _tmp 8425 self.pos = _save 8426 _tmp = apply(:_HtmlBlockFrameset) 8427 break if _tmp 8428 self.pos = _save 8429 _tmp = apply(:_HtmlBlockLi) 8430 break if _tmp 8431 self.pos = _save 8432 _tmp = apply(:_HtmlBlockTbody) 8433 break if _tmp 8434 self.pos = _save 8435 _tmp = apply(:_HtmlBlockTd) 8436 break if _tmp 8437 self.pos = _save 8438 _tmp = apply(:_HtmlBlockTfoot) 8439 break if _tmp 8440 self.pos = _save 8441 _tmp = apply(:_HtmlBlockTh) 8442 break if _tmp 8443 self.pos = _save 8444 _tmp = apply(:_HtmlBlockThead) 8445 break if _tmp 8446 self.pos = _save 8447 _tmp = apply(:_HtmlBlockTr) 8448 break if _tmp 8449 self.pos = _save 8450 _tmp = apply(:_HtmlBlockScript) 8451 break if _tmp 8452 self.pos = _save 8453 break 8454 end # end choice 8455 8456 set_failed_rule :_HtmlBlockInTags unless _tmp 8457 return _tmp 8458 end 8459 8460 # HtmlBlock = < (HtmlBlockInTags | HtmlComment | HtmlBlockSelfClosing | HtmlUnclosed) > BlankLine+ { if html? then RDoc::Markup::Raw.new text end } 8461 def _HtmlBlock 8462 8463 _save = self.pos 8464 while true # sequence 8465 _text_start = self.pos 8466 8467 _save1 = self.pos 8468 while true # choice 8469 _tmp = apply(:_HtmlBlockInTags) 8470 break if _tmp 8471 self.pos = _save1 8472 _tmp = apply(:_HtmlComment) 8473 break if _tmp 8474 self.pos = _save1 8475 _tmp = apply(:_HtmlBlockSelfClosing) 8476 break if _tmp 8477 self.pos = _save1 8478 _tmp = apply(:_HtmlUnclosed) 8479 break if _tmp 8480 self.pos = _save1 8481 break 8482 end # end choice 8483 8484 if _tmp 8485 text = get_text(_text_start) 8486 end 8487 unless _tmp 8488 self.pos = _save 8489 break 8490 end 8491 _save2 = self.pos 8492 _tmp = apply(:_BlankLine) 8493 if _tmp 8494 while true 8495 _tmp = apply(:_BlankLine) 8496 break unless _tmp 8497 end 8498 _tmp = true 8499 else 8500 self.pos = _save2 8501 end 8502 unless _tmp 8503 self.pos = _save 8504 break 8505 end 8506 @result = begin; if html? then 8507 RDoc::Markup::Raw.new text 8508 end ; end 8509 _tmp = true 8510 unless _tmp 8511 self.pos = _save 8512 end 8513 break 8514 end # end sequence 8515 8516 set_failed_rule :_HtmlBlock unless _tmp 8517 return _tmp 8518 end 8519 8520 # HtmlUnclosed = "<" Spnl HtmlUnclosedType Spnl HtmlAttribute* Spnl ">" 8521 def _HtmlUnclosed 8522 8523 _save = self.pos 8524 while true # sequence 8525 _tmp = match_string("<") 8526 unless _tmp 8527 self.pos = _save 8528 break 8529 end 8530 _tmp = apply(:_Spnl) 8531 unless _tmp 8532 self.pos = _save 8533 break 8534 end 8535 _tmp = apply(:_HtmlUnclosedType) 8536 unless _tmp 8537 self.pos = _save 8538 break 8539 end 8540 _tmp = apply(:_Spnl) 8541 unless _tmp 8542 self.pos = _save 8543 break 8544 end 8545 while true 8546 _tmp = apply(:_HtmlAttribute) 8547 break unless _tmp 8548 end 8549 _tmp = true 8550 unless _tmp 8551 self.pos = _save 8552 break 8553 end 8554 _tmp = apply(:_Spnl) 8555 unless _tmp 8556 self.pos = _save 8557 break 8558 end 8559 _tmp = match_string(">") 8560 unless _tmp 8561 self.pos = _save 8562 end 8563 break 8564 end # end sequence 8565 8566 set_failed_rule :_HtmlUnclosed unless _tmp 8567 return _tmp 8568 end 8569 8570 # HtmlUnclosedType = ("HR" | "hr") 8571 def _HtmlUnclosedType 8572 8573 _save = self.pos 8574 while true # choice 8575 _tmp = match_string("HR") 8576 break if _tmp 8577 self.pos = _save 8578 _tmp = match_string("hr") 8579 break if _tmp 8580 self.pos = _save 8581 break 8582 end # end choice 8583 8584 set_failed_rule :_HtmlUnclosedType unless _tmp 8585 return _tmp 8586 end 8587 8588 # HtmlBlockSelfClosing = "<" Spnl HtmlBlockType Spnl HtmlAttribute* "/" Spnl ">" 8589 def _HtmlBlockSelfClosing 8590 8591 _save = self.pos 8592 while true # sequence 8593 _tmp = match_string("<") 8594 unless _tmp 8595 self.pos = _save 8596 break 8597 end 8598 _tmp = apply(:_Spnl) 8599 unless _tmp 8600 self.pos = _save 8601 break 8602 end 8603 _tmp = apply(:_HtmlBlockType) 8604 unless _tmp 8605 self.pos = _save 8606 break 8607 end 8608 _tmp = apply(:_Spnl) 8609 unless _tmp 8610 self.pos = _save 8611 break 8612 end 8613 while true 8614 _tmp = apply(:_HtmlAttribute) 8615 break unless _tmp 8616 end 8617 _tmp = true 8618 unless _tmp 8619 self.pos = _save 8620 break 8621 end 8622 _tmp = match_string("/") 8623 unless _tmp 8624 self.pos = _save 8625 break 8626 end 8627 _tmp = apply(:_Spnl) 8628 unless _tmp 8629 self.pos = _save 8630 break 8631 end 8632 _tmp = match_string(">") 8633 unless _tmp 8634 self.pos = _save 8635 end 8636 break 8637 end # end sequence 8638 8639 set_failed_rule :_HtmlBlockSelfClosing unless _tmp 8640 return _tmp 8641 end 8642 8643 # HtmlBlockType = ("ADDRESS" | "BLOCKQUOTE" | "CENTER" | "DD" | "DIR" | "DIV" | "DL" | "DT" | "FIELDSET" | "FORM" | "FRAMESET" | "H1" | "H2" | "H3" | "H4" | "H5" | "H6" | "HR" | "ISINDEX" | "LI" | "MENU" | "NOFRAMES" | "NOSCRIPT" | "OL" | "P" | "PRE" | "SCRIPT" | "TABLE" | "TBODY" | "TD" | "TFOOT" | "TH" | "THEAD" | "TR" | "UL" | "address" | "blockquote" | "center" | "dd" | "dir" | "div" | "dl" | "dt" | "fieldset" | "form" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "hr" | "isindex" | "li" | "menu" | "noframes" | "noscript" | "ol" | "p" | "pre" | "script" | "table" | "tbody" | "td" | "tfoot" | "th" | "thead" | "tr" | "ul") 8644 def _HtmlBlockType 8645 8646 _save = self.pos 8647 while true # choice 8648 _tmp = match_string("ADDRESS") 8649 break if _tmp 8650 self.pos = _save 8651 _tmp = match_string("BLOCKQUOTE") 8652 break if _tmp 8653 self.pos = _save 8654 _tmp = match_string("CENTER") 8655 break if _tmp 8656 self.pos = _save 8657 _tmp = match_string("DD") 8658 break if _tmp 8659 self.pos = _save 8660 _tmp = match_string("DIR") 8661 break if _tmp 8662 self.pos = _save 8663 _tmp = match_string("DIV") 8664 break if _tmp 8665 self.pos = _save 8666 _tmp = match_string("DL") 8667 break if _tmp 8668 self.pos = _save 8669 _tmp = match_string("DT") 8670 break if _tmp 8671 self.pos = _save 8672 _tmp = match_string("FIELDSET") 8673 break if _tmp 8674 self.pos = _save 8675 _tmp = match_string("FORM") 8676 break if _tmp 8677 self.pos = _save 8678 _tmp = match_string("FRAMESET") 8679 break if _tmp 8680 self.pos = _save 8681 _tmp = match_string("H1") 8682 break if _tmp 8683 self.pos = _save 8684 _tmp = match_string("H2") 8685 break if _tmp 8686 self.pos = _save 8687 _tmp = match_string("H3") 8688 break if _tmp 8689 self.pos = _save 8690 _tmp = match_string("H4") 8691 break if _tmp 8692 self.pos = _save 8693 _tmp = match_string("H5") 8694 break if _tmp 8695 self.pos = _save 8696 _tmp = match_string("H6") 8697 break if _tmp 8698 self.pos = _save 8699 _tmp = match_string("HR") 8700 break if _tmp 8701 self.pos = _save 8702 _tmp = match_string("ISINDEX") 8703 break if _tmp 8704 self.pos = _save 8705 _tmp = match_string("LI") 8706 break if _tmp 8707 self.pos = _save 8708 _tmp = match_string("MENU") 8709 break if _tmp 8710 self.pos = _save 8711 _tmp = match_string("NOFRAMES") 8712 break if _tmp 8713 self.pos = _save 8714 _tmp = match_string("NOSCRIPT") 8715 break if _tmp 8716 self.pos = _save 8717 _tmp = match_string("OL") 8718 break if _tmp 8719 self.pos = _save 8720 _tmp = match_string("P") 8721 break if _tmp 8722 self.pos = _save 8723 _tmp = match_string("PRE") 8724 break if _tmp 8725 self.pos = _save 8726 _tmp = match_string("SCRIPT") 8727 break if _tmp 8728 self.pos = _save 8729 _tmp = match_string("TABLE") 8730 break if _tmp 8731 self.pos = _save 8732 _tmp = match_string("TBODY") 8733 break if _tmp 8734 self.pos = _save 8735 _tmp = match_string("TD") 8736 break if _tmp 8737 self.pos = _save 8738 _tmp = match_string("TFOOT") 8739 break if _tmp 8740 self.pos = _save 8741 _tmp = match_string("TH") 8742 break if _tmp 8743 self.pos = _save 8744 _tmp = match_string("THEAD") 8745 break if _tmp 8746 self.pos = _save 8747 _tmp = match_string("TR") 8748 break if _tmp 8749 self.pos = _save 8750 _tmp = match_string("UL") 8751 break if _tmp 8752 self.pos = _save 8753 _tmp = match_string("address") 8754 break if _tmp 8755 self.pos = _save 8756 _tmp = match_string("blockquote") 8757 break if _tmp 8758 self.pos = _save 8759 _tmp = match_string("center") 8760 break if _tmp 8761 self.pos = _save 8762 _tmp = match_string("dd") 8763 break if _tmp 8764 self.pos = _save 8765 _tmp = match_string("dir") 8766 break if _tmp 8767 self.pos = _save 8768 _tmp = match_string("div") 8769 break if _tmp 8770 self.pos = _save 8771 _tmp = match_string("dl") 8772 break if _tmp 8773 self.pos = _save 8774 _tmp = match_string("dt") 8775 break if _tmp 8776 self.pos = _save 8777 _tmp = match_string("fieldset") 8778 break if _tmp 8779 self.pos = _save 8780 _tmp = match_string("form") 8781 break if _tmp 8782 self.pos = _save 8783 _tmp = match_string("frameset") 8784 break if _tmp 8785 self.pos = _save 8786 _tmp = match_string("h1") 8787 break if _tmp 8788 self.pos = _save 8789 _tmp = match_string("h2") 8790 break if _tmp 8791 self.pos = _save 8792 _tmp = match_string("h3") 8793 break if _tmp 8794 self.pos = _save 8795 _tmp = match_string("h4") 8796 break if _tmp 8797 self.pos = _save 8798 _tmp = match_string("h5") 8799 break if _tmp 8800 self.pos = _save 8801 _tmp = match_string("h6") 8802 break if _tmp 8803 self.pos = _save 8804 _tmp = match_string("hr") 8805 break if _tmp 8806 self.pos = _save 8807 _tmp = match_string("isindex") 8808 break if _tmp 8809 self.pos = _save 8810 _tmp = match_string("li") 8811 break if _tmp 8812 self.pos = _save 8813 _tmp = match_string("menu") 8814 break if _tmp 8815 self.pos = _save 8816 _tmp = match_string("noframes") 8817 break if _tmp 8818 self.pos = _save 8819 _tmp = match_string("noscript") 8820 break if _tmp 8821 self.pos = _save 8822 _tmp = match_string("ol") 8823 break if _tmp 8824 self.pos = _save 8825 _tmp = match_string("p") 8826 break if _tmp 8827 self.pos = _save 8828 _tmp = match_string("pre") 8829 break if _tmp 8830 self.pos = _save 8831 _tmp = match_string("script") 8832 break if _tmp 8833 self.pos = _save 8834 _tmp = match_string("table") 8835 break if _tmp 8836 self.pos = _save 8837 _tmp = match_string("tbody") 8838 break if _tmp 8839 self.pos = _save 8840 _tmp = match_string("td") 8841 break if _tmp 8842 self.pos = _save 8843 _tmp = match_string("tfoot") 8844 break if _tmp 8845 self.pos = _save 8846 _tmp = match_string("th") 8847 break if _tmp 8848 self.pos = _save 8849 _tmp = match_string("thead") 8850 break if _tmp 8851 self.pos = _save 8852 _tmp = match_string("tr") 8853 break if _tmp 8854 self.pos = _save 8855 _tmp = match_string("ul") 8856 break if _tmp 8857 self.pos = _save 8858 break 8859 end # end choice 8860 8861 set_failed_rule :_HtmlBlockType unless _tmp 8862 return _tmp 8863 end 8864 8865 # StyleOpen = "<" Spnl ("style" | "STYLE") Spnl HtmlAttribute* ">" 8866 def _StyleOpen 8867 8868 _save = self.pos 8869 while true # sequence 8870 _tmp = match_string("<") 8871 unless _tmp 8872 self.pos = _save 8873 break 8874 end 8875 _tmp = apply(:_Spnl) 8876 unless _tmp 8877 self.pos = _save 8878 break 8879 end 8880 8881 _save1 = self.pos 8882 while true # choice 8883 _tmp = match_string("style") 8884 break if _tmp 8885 self.pos = _save1 8886 _tmp = match_string("STYLE") 8887 break if _tmp 8888 self.pos = _save1 8889 break 8890 end # end choice 8891 8892 unless _tmp 8893 self.pos = _save 8894 break 8895 end 8896 _tmp = apply(:_Spnl) 8897 unless _tmp 8898 self.pos = _save 8899 break 8900 end 8901 while true 8902 _tmp = apply(:_HtmlAttribute) 8903 break unless _tmp 8904 end 8905 _tmp = true 8906 unless _tmp 8907 self.pos = _save 8908 break 8909 end 8910 _tmp = match_string(">") 8911 unless _tmp 8912 self.pos = _save 8913 end 8914 break 8915 end # end sequence 8916 8917 set_failed_rule :_StyleOpen unless _tmp 8918 return _tmp 8919 end 8920 8921 # StyleClose = "<" Spnl "/" ("style" | "STYLE") Spnl ">" 8922 def _StyleClose 8923 8924 _save = self.pos 8925 while true # sequence 8926 _tmp = match_string("<") 8927 unless _tmp 8928 self.pos = _save 8929 break 8930 end 8931 _tmp = apply(:_Spnl) 8932 unless _tmp 8933 self.pos = _save 8934 break 8935 end 8936 _tmp = match_string("/") 8937 unless _tmp 8938 self.pos = _save 8939 break 8940 end 8941 8942 _save1 = self.pos 8943 while true # choice 8944 _tmp = match_string("style") 8945 break if _tmp 8946 self.pos = _save1 8947 _tmp = match_string("STYLE") 8948 break if _tmp 8949 self.pos = _save1 8950 break 8951 end # end choice 8952 8953 unless _tmp 8954 self.pos = _save 8955 break 8956 end 8957 _tmp = apply(:_Spnl) 8958 unless _tmp 8959 self.pos = _save 8960 break 8961 end 8962 _tmp = match_string(">") 8963 unless _tmp 8964 self.pos = _save 8965 end 8966 break 8967 end # end sequence 8968 8969 set_failed_rule :_StyleClose unless _tmp 8970 return _tmp 8971 end 8972 8973 # InStyleTags = StyleOpen (!StyleClose .)* StyleClose 8974 def _InStyleTags 8975 8976 _save = self.pos 8977 while true # sequence 8978 _tmp = apply(:_StyleOpen) 8979 unless _tmp 8980 self.pos = _save 8981 break 8982 end 8983 while true 8984 8985 _save2 = self.pos 8986 while true # sequence 8987 _save3 = self.pos 8988 _tmp = apply(:_StyleClose) 8989 _tmp = _tmp ? nil : true 8990 self.pos = _save3 8991 unless _tmp 8992 self.pos = _save2 8993 break 8994 end 8995 _tmp = get_byte 8996 unless _tmp 8997 self.pos = _save2 8998 end 8999 break 9000 end # end sequence 9001 9002 break unless _tmp 9003 end 9004 _tmp = true 9005 unless _tmp 9006 self.pos = _save 9007 break 9008 end 9009 _tmp = apply(:_StyleClose) 9010 unless _tmp 9011 self.pos = _save 9012 end 9013 break 9014 end # end sequence 9015 9016 set_failed_rule :_InStyleTags unless _tmp 9017 return _tmp 9018 end 9019 9020 # StyleBlock = < InStyleTags > BlankLine* { if css? then RDoc::Markup::Raw.new text end } 9021 def _StyleBlock 9022 9023 _save = self.pos 9024 while true # sequence 9025 _text_start = self.pos 9026 _tmp = apply(:_InStyleTags) 9027 if _tmp 9028 text = get_text(_text_start) 9029 end 9030 unless _tmp 9031 self.pos = _save 9032 break 9033 end 9034 while true 9035 _tmp = apply(:_BlankLine) 9036 break unless _tmp 9037 end 9038 _tmp = true 9039 unless _tmp 9040 self.pos = _save 9041 break 9042 end 9043 @result = begin; if css? then 9044 RDoc::Markup::Raw.new text 9045 end ; end 9046 _tmp = true 9047 unless _tmp 9048 self.pos = _save 9049 end 9050 break 9051 end # end sequence 9052 9053 set_failed_rule :_StyleBlock unless _tmp 9054 return _tmp 9055 end 9056 9057 # Inlines = (!Endline Inline:i { i } | Endline:c &Inline { c })+:chunks Endline? { chunks } 9058 def _Inlines 9059 9060 _save = self.pos 9061 while true # sequence 9062 _save1 = self.pos 9063 _ary = [] 9064 9065 _save2 = self.pos 9066 while true # choice 9067 9068 _save3 = self.pos 9069 while true # sequence 9070 _save4 = self.pos 9071 _tmp = apply(:_Endline) 9072 _tmp = _tmp ? nil : true 9073 self.pos = _save4 9074 unless _tmp 9075 self.pos = _save3 9076 break 9077 end 9078 _tmp = apply(:_Inline) 9079 i = @result 9080 unless _tmp 9081 self.pos = _save3 9082 break 9083 end 9084 @result = begin; i ; end 9085 _tmp = true 9086 unless _tmp 9087 self.pos = _save3 9088 end 9089 break 9090 end # end sequence 9091 9092 break if _tmp 9093 self.pos = _save2 9094 9095 _save5 = self.pos 9096 while true # sequence 9097 _tmp = apply(:_Endline) 9098 c = @result 9099 unless _tmp 9100 self.pos = _save5 9101 break 9102 end 9103 _save6 = self.pos 9104 _tmp = apply(:_Inline) 9105 self.pos = _save6 9106 unless _tmp 9107 self.pos = _save5 9108 break 9109 end 9110 @result = begin; c ; end 9111 _tmp = true 9112 unless _tmp 9113 self.pos = _save5 9114 end 9115 break 9116 end # end sequence 9117 9118 break if _tmp 9119 self.pos = _save2 9120 break 9121 end # end choice 9122 9123 if _tmp 9124 _ary << @result 9125 while true 9126 9127 _save7 = self.pos 9128 while true # choice 9129 9130 _save8 = self.pos 9131 while true # sequence 9132 _save9 = self.pos 9133 _tmp = apply(:_Endline) 9134 _tmp = _tmp ? nil : true 9135 self.pos = _save9 9136 unless _tmp 9137 self.pos = _save8 9138 break 9139 end 9140 _tmp = apply(:_Inline) 9141 i = @result 9142 unless _tmp 9143 self.pos = _save8 9144 break 9145 end 9146 @result = begin; i ; end 9147 _tmp = true 9148 unless _tmp 9149 self.pos = _save8 9150 end 9151 break 9152 end # end sequence 9153 9154 break if _tmp 9155 self.pos = _save7 9156 9157 _save10 = self.pos 9158 while true # sequence 9159 _tmp = apply(:_Endline) 9160 c = @result 9161 unless _tmp 9162 self.pos = _save10 9163 break 9164 end 9165 _save11 = self.pos 9166 _tmp = apply(:_Inline) 9167 self.pos = _save11 9168 unless _tmp 9169 self.pos = _save10 9170 break 9171 end 9172 @result = begin; c ; end 9173 _tmp = true 9174 unless _tmp 9175 self.pos = _save10 9176 end 9177 break 9178 end # end sequence 9179 9180 break if _tmp 9181 self.pos = _save7 9182 break 9183 end # end choice 9184 9185 _ary << @result if _tmp 9186 break unless _tmp 9187 end 9188 _tmp = true 9189 @result = _ary 9190 else 9191 self.pos = _save1 9192 end 9193 chunks = @result 9194 unless _tmp 9195 self.pos = _save 9196 break 9197 end 9198 _save12 = self.pos 9199 _tmp = apply(:_Endline) 9200 unless _tmp 9201 _tmp = true 9202 self.pos = _save12 9203 end 9204 unless _tmp 9205 self.pos = _save 9206 break 9207 end 9208 @result = begin; chunks ; end 9209 _tmp = true 9210 unless _tmp 9211 self.pos = _save 9212 end 9213 break 9214 end # end sequence 9215 9216 set_failed_rule :_Inlines unless _tmp 9217 return _tmp 9218 end 9219 9220 # Inline = (Str | Endline | UlOrStarLine | Space | Strong | Emph | Image | Link | NoteReference | InlineNote | Code | RawHtml | Entity | EscapedChar | Symbol) 9221 def _Inline 9222 9223 _save = self.pos 9224 while true # choice 9225 _tmp = apply(:_Str) 9226 break if _tmp 9227 self.pos = _save 9228 _tmp = apply(:_Endline) 9229 break if _tmp 9230 self.pos = _save 9231 _tmp = apply(:_UlOrStarLine) 9232 break if _tmp 9233 self.pos = _save 9234 _tmp = apply(:_Space) 9235 break if _tmp 9236 self.pos = _save 9237 _tmp = apply(:_Strong) 9238 break if _tmp 9239 self.pos = _save 9240 _tmp = apply(:_Emph) 9241 break if _tmp 9242 self.pos = _save 9243 _tmp = apply(:_Image) 9244 break if _tmp 9245 self.pos = _save 9246 _tmp = apply(:_Link) 9247 break if _tmp 9248 self.pos = _save 9249 _tmp = apply(:_NoteReference) 9250 break if _tmp 9251 self.pos = _save 9252 _tmp = apply(:_InlineNote) 9253 break if _tmp 9254 self.pos = _save 9255 _tmp = apply(:_Code) 9256 break if _tmp 9257 self.pos = _save 9258 _tmp = apply(:_RawHtml) 9259 break if _tmp 9260 self.pos = _save 9261 _tmp = apply(:_Entity) 9262 break if _tmp 9263 self.pos = _save 9264 _tmp = apply(:_EscapedChar) 9265 break if _tmp 9266 self.pos = _save 9267 _tmp = apply(:_Symbol) 9268 break if _tmp 9269 self.pos = _save 9270 break 9271 end # end choice 9272 9273 set_failed_rule :_Inline unless _tmp 9274 return _tmp 9275 end 9276 9277 # Space = Spacechar+ { " " } 9278 def _Space 9279 9280 _save = self.pos 9281 while true # sequence 9282 _save1 = self.pos 9283 _tmp = apply(:_Spacechar) 9284 if _tmp 9285 while true 9286 _tmp = apply(:_Spacechar) 9287 break unless _tmp 9288 end 9289 _tmp = true 9290 else 9291 self.pos = _save1 9292 end 9293 unless _tmp 9294 self.pos = _save 9295 break 9296 end 9297 @result = begin; " " ; end 9298 _tmp = true 9299 unless _tmp 9300 self.pos = _save 9301 end 9302 break 9303 end # end sequence 9304 9305 set_failed_rule :_Space unless _tmp 9306 return _tmp 9307 end 9308 9309 # Str = StartList:a < NormalChar+ > { a = text } (StrChunk:c { a << c })* { a } 9310 def _Str 9311 9312 _save = self.pos 9313 while true # sequence 9314 _tmp = apply(:_StartList) 9315 a = @result 9316 unless _tmp 9317 self.pos = _save 9318 break 9319 end 9320 _text_start = self.pos 9321 _save1 = self.pos 9322 _tmp = apply(:_NormalChar) 9323 if _tmp 9324 while true 9325 _tmp = apply(:_NormalChar) 9326 break unless _tmp 9327 end 9328 _tmp = true 9329 else 9330 self.pos = _save1 9331 end 9332 if _tmp 9333 text = get_text(_text_start) 9334 end 9335 unless _tmp 9336 self.pos = _save 9337 break 9338 end 9339 @result = begin; a = text ; end 9340 _tmp = true 9341 unless _tmp 9342 self.pos = _save 9343 break 9344 end 9345 while true 9346 9347 _save3 = self.pos 9348 while true # sequence 9349 _tmp = apply(:_StrChunk) 9350 c = @result 9351 unless _tmp 9352 self.pos = _save3 9353 break 9354 end 9355 @result = begin; a << c ; end 9356 _tmp = true 9357 unless _tmp 9358 self.pos = _save3 9359 end 9360 break 9361 end # end sequence 9362 9363 break unless _tmp 9364 end 9365 _tmp = true 9366 unless _tmp 9367 self.pos = _save 9368 break 9369 end 9370 @result = begin; a ; end 9371 _tmp = true 9372 unless _tmp 9373 self.pos = _save 9374 end 9375 break 9376 end # end sequence 9377 9378 set_failed_rule :_Str unless _tmp 9379 return _tmp 9380 end 9381 9382 # StrChunk = < (NormalChar | "_"+ &Alphanumeric)+ > { text } 9383 def _StrChunk 9384 9385 _save = self.pos 9386 while true # sequence 9387 _text_start = self.pos 9388 _save1 = self.pos 9389 9390 _save2 = self.pos 9391 while true # choice 9392 _tmp = apply(:_NormalChar) 9393 break if _tmp 9394 self.pos = _save2 9395 9396 _save3 = self.pos 9397 while true # sequence 9398 _save4 = self.pos 9399 _tmp = match_string("_") 9400 if _tmp 9401 while true 9402 _tmp = match_string("_") 9403 break unless _tmp 9404 end 9405 _tmp = true 9406 else 9407 self.pos = _save4 9408 end 9409 unless _tmp 9410 self.pos = _save3 9411 break 9412 end 9413 _save5 = self.pos 9414 _tmp = apply(:_Alphanumeric) 9415 self.pos = _save5 9416 unless _tmp 9417 self.pos = _save3 9418 end 9419 break 9420 end # end sequence 9421 9422 break if _tmp 9423 self.pos = _save2 9424 break 9425 end # end choice 9426 9427 if _tmp 9428 while true 9429 9430 _save6 = self.pos 9431 while true # choice 9432 _tmp = apply(:_NormalChar) 9433 break if _tmp 9434 self.pos = _save6 9435 9436 _save7 = self.pos 9437 while true # sequence 9438 _save8 = self.pos 9439 _tmp = match_string("_") 9440 if _tmp 9441 while true 9442 _tmp = match_string("_") 9443 break unless _tmp 9444 end 9445 _tmp = true 9446 else 9447 self.pos = _save8 9448 end 9449 unless _tmp 9450 self.pos = _save7 9451 break 9452 end 9453 _save9 = self.pos 9454 _tmp = apply(:_Alphanumeric) 9455 self.pos = _save9 9456 unless _tmp 9457 self.pos = _save7 9458 end 9459 break 9460 end # end sequence 9461 9462 break if _tmp 9463 self.pos = _save6 9464 break 9465 end # end choice 9466 9467 break unless _tmp 9468 end 9469 _tmp = true 9470 else 9471 self.pos = _save1 9472 end 9473 if _tmp 9474 text = get_text(_text_start) 9475 end 9476 unless _tmp 9477 self.pos = _save 9478 break 9479 end 9480 @result = begin; text ; end 9481 _tmp = true 9482 unless _tmp 9483 self.pos = _save 9484 end 9485 break 9486 end # end sequence 9487 9488 set_failed_rule :_StrChunk unless _tmp 9489 return _tmp 9490 end 9491 9492 # EscapedChar = "\\" !Newline < /[:\\`|*_{}\[\]()#+.!><-]/ > { text } 9493 def _EscapedChar 9494 9495 _save = self.pos 9496 while true # sequence 9497 _tmp = match_string("\\") 9498 unless _tmp 9499 self.pos = _save 9500 break 9501 end 9502 _save1 = self.pos 9503 _tmp = apply(:_Newline) 9504 _tmp = _tmp ? nil : true 9505 self.pos = _save1 9506 unless _tmp 9507 self.pos = _save 9508 break 9509 end 9510 _text_start = self.pos 9511 _tmp = scan(/\A(?-mix:[:\\`|*_{}\[\]()#+.!><-])/) 9512 if _tmp 9513 text = get_text(_text_start) 9514 end 9515 unless _tmp 9516 self.pos = _save 9517 break 9518 end 9519 @result = begin; text ; end 9520 _tmp = true 9521 unless _tmp 9522 self.pos = _save 9523 end 9524 break 9525 end # end sequence 9526 9527 set_failed_rule :_EscapedChar unless _tmp 9528 return _tmp 9529 end 9530 9531 # Entity = (HexEntity | DecEntity | CharEntity):a { a } 9532 def _Entity 9533 9534 _save = self.pos 9535 while true # sequence 9536 9537 _save1 = self.pos 9538 while true # choice 9539 _tmp = apply(:_HexEntity) 9540 break if _tmp 9541 self.pos = _save1 9542 _tmp = apply(:_DecEntity) 9543 break if _tmp 9544 self.pos = _save1 9545 _tmp = apply(:_CharEntity) 9546 break if _tmp 9547 self.pos = _save1 9548 break 9549 end # end choice 9550 9551 a = @result 9552 unless _tmp 9553 self.pos = _save 9554 break 9555 end 9556 @result = begin; a ; end 9557 _tmp = true 9558 unless _tmp 9559 self.pos = _save 9560 end 9561 break 9562 end # end sequence 9563 9564 set_failed_rule :_Entity unless _tmp 9565 return _tmp 9566 end 9567 9568 # Endline = (LineBreak | TerminalEndline | NormalEndline) 9569 def _Endline 9570 9571 _save = self.pos 9572 while true # choice 9573 _tmp = apply(:_LineBreak) 9574 break if _tmp 9575 self.pos = _save 9576 _tmp = apply(:_TerminalEndline) 9577 break if _tmp 9578 self.pos = _save 9579 _tmp = apply(:_NormalEndline) 9580 break if _tmp 9581 self.pos = _save 9582 break 9583 end # end choice 9584 9585 set_failed_rule :_Endline unless _tmp 9586 return _tmp 9587 end 9588 9589 # NormalEndline = Sp Newline !BlankLine !">" !AtxStart !(Line ("===" "="* | "---" "-"*) Newline) { "\n" } 9590 def _NormalEndline 9591 9592 _save = self.pos 9593 while true # sequence 9594 _tmp = apply(:_Sp) 9595 unless _tmp 9596 self.pos = _save 9597 break 9598 end 9599 _tmp = apply(:_Newline) 9600 unless _tmp 9601 self.pos = _save 9602 break 9603 end 9604 _save1 = self.pos 9605 _tmp = apply(:_BlankLine) 9606 _tmp = _tmp ? nil : true 9607 self.pos = _save1 9608 unless _tmp 9609 self.pos = _save 9610 break 9611 end 9612 _save2 = self.pos 9613 _tmp = match_string(">") 9614 _tmp = _tmp ? nil : true 9615 self.pos = _save2 9616 unless _tmp 9617 self.pos = _save 9618 break 9619 end 9620 _save3 = self.pos 9621 _tmp = apply(:_AtxStart) 9622 _tmp = _tmp ? nil : true 9623 self.pos = _save3 9624 unless _tmp 9625 self.pos = _save 9626 break 9627 end 9628 _save4 = self.pos 9629 9630 _save5 = self.pos 9631 while true # sequence 9632 _tmp = apply(:_Line) 9633 unless _tmp 9634 self.pos = _save5 9635 break 9636 end 9637 9638 _save6 = self.pos 9639 while true # choice 9640 9641 _save7 = self.pos 9642 while true # sequence 9643 _tmp = match_string("===") 9644 unless _tmp 9645 self.pos = _save7 9646 break 9647 end 9648 while true 9649 _tmp = match_string("=") 9650 break unless _tmp 9651 end 9652 _tmp = true 9653 unless _tmp 9654 self.pos = _save7 9655 end 9656 break 9657 end # end sequence 9658 9659 break if _tmp 9660 self.pos = _save6 9661 9662 _save9 = self.pos 9663 while true # sequence 9664 _tmp = match_string("---") 9665 unless _tmp 9666 self.pos = _save9 9667 break 9668 end 9669 while true 9670 _tmp = match_string("-") 9671 break unless _tmp 9672 end 9673 _tmp = true 9674 unless _tmp 9675 self.pos = _save9 9676 end 9677 break 9678 end # end sequence 9679 9680 break if _tmp 9681 self.pos = _save6 9682 break 9683 end # end choice 9684 9685 unless _tmp 9686 self.pos = _save5 9687 break 9688 end 9689 _tmp = apply(:_Newline) 9690 unless _tmp 9691 self.pos = _save5 9692 end 9693 break 9694 end # end sequence 9695 9696 _tmp = _tmp ? nil : true 9697 self.pos = _save4 9698 unless _tmp 9699 self.pos = _save 9700 break 9701 end 9702 @result = begin; "\n" ; end 9703 _tmp = true 9704 unless _tmp 9705 self.pos = _save 9706 end 9707 break 9708 end # end sequence 9709 9710 set_failed_rule :_NormalEndline unless _tmp 9711 return _tmp 9712 end 9713 9714 # TerminalEndline = Sp Newline Eof 9715 def _TerminalEndline 9716 9717 _save = self.pos 9718 while true # sequence 9719 _tmp = apply(:_Sp) 9720 unless _tmp 9721 self.pos = _save 9722 break 9723 end 9724 _tmp = apply(:_Newline) 9725 unless _tmp 9726 self.pos = _save 9727 break 9728 end 9729 _tmp = apply(:_Eof) 9730 unless _tmp 9731 self.pos = _save 9732 end 9733 break 9734 end # end sequence 9735 9736 set_failed_rule :_TerminalEndline unless _tmp 9737 return _tmp 9738 end 9739 9740 # LineBreak = " " NormalEndline { RDoc::Markup::HardBreak.new } 9741 def _LineBreak 9742 9743 _save = self.pos 9744 while true # sequence 9745 _tmp = match_string(" ") 9746 unless _tmp 9747 self.pos = _save 9748 break 9749 end 9750 _tmp = apply(:_NormalEndline) 9751 unless _tmp 9752 self.pos = _save 9753 break 9754 end 9755 @result = begin; RDoc::Markup::HardBreak.new ; end 9756 _tmp = true 9757 unless _tmp 9758 self.pos = _save 9759 end 9760 break 9761 end # end sequence 9762 9763 set_failed_rule :_LineBreak unless _tmp 9764 return _tmp 9765 end 9766 9767 # Symbol = < SpecialChar > { text } 9768 def _Symbol 9769 9770 _save = self.pos 9771 while true # sequence 9772 _text_start = self.pos 9773 _tmp = apply(:_SpecialChar) 9774 if _tmp 9775 text = get_text(_text_start) 9776 end 9777 unless _tmp 9778 self.pos = _save 9779 break 9780 end 9781 @result = begin; text ; end 9782 _tmp = true 9783 unless _tmp 9784 self.pos = _save 9785 end 9786 break 9787 end # end sequence 9788 9789 set_failed_rule :_Symbol unless _tmp 9790 return _tmp 9791 end 9792 9793 # UlOrStarLine = (UlLine | StarLine):a { a } 9794 def _UlOrStarLine 9795 9796 _save = self.pos 9797 while true # sequence 9798 9799 _save1 = self.pos 9800 while true # choice 9801 _tmp = apply(:_UlLine) 9802 break if _tmp 9803 self.pos = _save1 9804 _tmp = apply(:_StarLine) 9805 break if _tmp 9806 self.pos = _save1 9807 break 9808 end # end choice 9809 9810 a = @result 9811 unless _tmp 9812 self.pos = _save 9813 break 9814 end 9815 @result = begin; a ; end 9816 _tmp = true 9817 unless _tmp 9818 self.pos = _save 9819 end 9820 break 9821 end # end sequence 9822 9823 set_failed_rule :_UlOrStarLine unless _tmp 9824 return _tmp 9825 end 9826 9827 # StarLine = (< "****" "*"* > { text } | < Spacechar "*"+ &Spacechar > { text }) 9828 def _StarLine 9829 9830 _save = self.pos 9831 while true # choice 9832 9833 _save1 = self.pos 9834 while true # sequence 9835 _text_start = self.pos 9836 9837 _save2 = self.pos 9838 while true # sequence 9839 _tmp = match_string("****") 9840 unless _tmp 9841 self.pos = _save2 9842 break 9843 end 9844 while true 9845 _tmp = match_string("*") 9846 break unless _tmp 9847 end 9848 _tmp = true 9849 unless _tmp 9850 self.pos = _save2 9851 end 9852 break 9853 end # end sequence 9854 9855 if _tmp 9856 text = get_text(_text_start) 9857 end 9858 unless _tmp 9859 self.pos = _save1 9860 break 9861 end 9862 @result = begin; text ; end 9863 _tmp = true 9864 unless _tmp 9865 self.pos = _save1 9866 end 9867 break 9868 end # end sequence 9869 9870 break if _tmp 9871 self.pos = _save 9872 9873 _save4 = self.pos 9874 while true # sequence 9875 _text_start = self.pos 9876 9877 _save5 = self.pos 9878 while true # sequence 9879 _tmp = apply(:_Spacechar) 9880 unless _tmp 9881 self.pos = _save5 9882 break 9883 end 9884 _save6 = self.pos 9885 _tmp = match_string("*") 9886 if _tmp 9887 while true 9888 _tmp = match_string("*") 9889 break unless _tmp 9890 end 9891 _tmp = true 9892 else 9893 self.pos = _save6 9894 end 9895 unless _tmp 9896 self.pos = _save5 9897 break 9898 end 9899 _save7 = self.pos 9900 _tmp = apply(:_Spacechar) 9901 self.pos = _save7 9902 unless _tmp 9903 self.pos = _save5 9904 end 9905 break 9906 end # end sequence 9907 9908 if _tmp 9909 text = get_text(_text_start) 9910 end 9911 unless _tmp 9912 self.pos = _save4 9913 break 9914 end 9915 @result = begin; text ; end 9916 _tmp = true 9917 unless _tmp 9918 self.pos = _save4 9919 end 9920 break 9921 end # end sequence 9922 9923 break if _tmp 9924 self.pos = _save 9925 break 9926 end # end choice 9927 9928 set_failed_rule :_StarLine unless _tmp 9929 return _tmp 9930 end 9931 9932 # UlLine = (< "____" "_"* > { text } | < Spacechar "_"+ &Spacechar > { text }) 9933 def _UlLine 9934 9935 _save = self.pos 9936 while true # choice 9937 9938 _save1 = self.pos 9939 while true # sequence 9940 _text_start = self.pos 9941 9942 _save2 = self.pos 9943 while true # sequence 9944 _tmp = match_string("____") 9945 unless _tmp 9946 self.pos = _save2 9947 break 9948 end 9949 while true 9950 _tmp = match_string("_") 9951 break unless _tmp 9952 end 9953 _tmp = true 9954 unless _tmp 9955 self.pos = _save2 9956 end 9957 break 9958 end # end sequence 9959 9960 if _tmp 9961 text = get_text(_text_start) 9962 end 9963 unless _tmp 9964 self.pos = _save1 9965 break 9966 end 9967 @result = begin; text ; end 9968 _tmp = true 9969 unless _tmp 9970 self.pos = _save1 9971 end 9972 break 9973 end # end sequence 9974 9975 break if _tmp 9976 self.pos = _save 9977 9978 _save4 = self.pos 9979 while true # sequence 9980 _text_start = self.pos 9981 9982 _save5 = self.pos 9983 while true # sequence 9984 _tmp = apply(:_Spacechar) 9985 unless _tmp 9986 self.pos = _save5 9987 break 9988 end 9989 _save6 = self.pos 9990 _tmp = match_string("_") 9991 if _tmp 9992 while true 9993 _tmp = match_string("_") 9994 break unless _tmp 9995 end 9996 _tmp = true 9997 else 9998 self.pos = _save6 9999 end 10000 unless _tmp 10001 self.pos = _save5 10002 break 10003 end 10004 _save7 = self.pos 10005 _tmp = apply(:_Spacechar) 10006 self.pos = _save7 10007 unless _tmp 10008 self.pos = _save5 10009 end 10010 break 10011 end # end sequence 10012 10013 if _tmp 10014 text = get_text(_text_start) 10015 end 10016 unless _tmp 10017 self.pos = _save4 10018 break 10019 end 10020 @result = begin; text ; end 10021 _tmp = true 10022 unless _tmp 10023 self.pos = _save4 10024 end 10025 break 10026 end # end sequence 10027 10028 break if _tmp 10029 self.pos = _save 10030 break 10031 end # end choice 10032 10033 set_failed_rule :_UlLine unless _tmp 10034 return _tmp 10035 end 10036 10037 # Emph = (EmphStar | EmphUl) 10038 def _Emph 10039 10040 _save = self.pos 10041 while true # choice 10042 _tmp = apply(:_EmphStar) 10043 break if _tmp 10044 self.pos = _save 10045 _tmp = apply(:_EmphUl) 10046 break if _tmp 10047 self.pos = _save 10048 break 10049 end # end choice 10050 10051 set_failed_rule :_Emph unless _tmp 10052 return _tmp 10053 end 10054 10055 # OneStarOpen = !StarLine "*" !Spacechar !Newline 10056 def _OneStarOpen 10057 10058 _save = self.pos 10059 while true # sequence 10060 _save1 = self.pos 10061 _tmp = apply(:_StarLine) 10062 _tmp = _tmp ? nil : true 10063 self.pos = _save1 10064 unless _tmp 10065 self.pos = _save 10066 break 10067 end 10068 _tmp = match_string("*") 10069 unless _tmp 10070 self.pos = _save 10071 break 10072 end 10073 _save2 = self.pos 10074 _tmp = apply(:_Spacechar) 10075 _tmp = _tmp ? nil : true 10076 self.pos = _save2 10077 unless _tmp 10078 self.pos = _save 10079 break 10080 end 10081 _save3 = self.pos 10082 _tmp = apply(:_Newline) 10083 _tmp = _tmp ? nil : true 10084 self.pos = _save3 10085 unless _tmp 10086 self.pos = _save 10087 end 10088 break 10089 end # end sequence 10090 10091 set_failed_rule :_OneStarOpen unless _tmp 10092 return _tmp 10093 end 10094 10095 # OneStarClose = !Spacechar !Newline Inline:a "*" { a } 10096 def _OneStarClose 10097 10098 _save = self.pos 10099 while true # sequence 10100 _save1 = self.pos 10101 _tmp = apply(:_Spacechar) 10102 _tmp = _tmp ? nil : true 10103 self.pos = _save1 10104 unless _tmp 10105 self.pos = _save 10106 break 10107 end 10108 _save2 = self.pos 10109 _tmp = apply(:_Newline) 10110 _tmp = _tmp ? nil : true 10111 self.pos = _save2 10112 unless _tmp 10113 self.pos = _save 10114 break 10115 end 10116 _tmp = apply(:_Inline) 10117 a = @result 10118 unless _tmp 10119 self.pos = _save 10120 break 10121 end 10122 _tmp = match_string("*") 10123 unless _tmp 10124 self.pos = _save 10125 break 10126 end 10127 @result = begin; a ; end 10128 _tmp = true 10129 unless _tmp 10130 self.pos = _save 10131 end 10132 break 10133 end # end sequence 10134 10135 set_failed_rule :_OneStarClose unless _tmp 10136 return _tmp 10137 end 10138 10139 # EmphStar = OneStarOpen StartList:a (!OneStarClose Inline:l { a << l })* OneStarClose:l { a << l } { emphasis a.join } 10140 def _EmphStar 10141 10142 _save = self.pos 10143 while true # sequence 10144 _tmp = apply(:_OneStarOpen) 10145 unless _tmp 10146 self.pos = _save 10147 break 10148 end 10149 _tmp = apply(:_StartList) 10150 a = @result 10151 unless _tmp 10152 self.pos = _save 10153 break 10154 end 10155 while true 10156 10157 _save2 = self.pos 10158 while true # sequence 10159 _save3 = self.pos 10160 _tmp = apply(:_OneStarClose) 10161 _tmp = _tmp ? nil : true 10162 self.pos = _save3 10163 unless _tmp 10164 self.pos = _save2 10165 break 10166 end 10167 _tmp = apply(:_Inline) 10168 l = @result 10169 unless _tmp 10170 self.pos = _save2 10171 break 10172 end 10173 @result = begin; a << l ; end 10174 _tmp = true 10175 unless _tmp 10176 self.pos = _save2 10177 end 10178 break 10179 end # end sequence 10180 10181 break unless _tmp 10182 end 10183 _tmp = true 10184 unless _tmp 10185 self.pos = _save 10186 break 10187 end 10188 _tmp = apply(:_OneStarClose) 10189 l = @result 10190 unless _tmp 10191 self.pos = _save 10192 break 10193 end 10194 @result = begin; a << l ; end 10195 _tmp = true 10196 unless _tmp 10197 self.pos = _save 10198 break 10199 end 10200 @result = begin; emphasis a.join ; end 10201 _tmp = true 10202 unless _tmp 10203 self.pos = _save 10204 end 10205 break 10206 end # end sequence 10207 10208 set_failed_rule :_EmphStar unless _tmp 10209 return _tmp 10210 end 10211 10212 # OneUlOpen = !UlLine "_" !Spacechar !Newline 10213 def _OneUlOpen 10214 10215 _save = self.pos 10216 while true # sequence 10217 _save1 = self.pos 10218 _tmp = apply(:_UlLine) 10219 _tmp = _tmp ? nil : true 10220 self.pos = _save1 10221 unless _tmp 10222 self.pos = _save 10223 break 10224 end 10225 _tmp = match_string("_") 10226 unless _tmp 10227 self.pos = _save 10228 break 10229 end 10230 _save2 = self.pos 10231 _tmp = apply(:_Spacechar) 10232 _tmp = _tmp ? nil : true 10233 self.pos = _save2 10234 unless _tmp 10235 self.pos = _save 10236 break 10237 end 10238 _save3 = self.pos 10239 _tmp = apply(:_Newline) 10240 _tmp = _tmp ? nil : true 10241 self.pos = _save3 10242 unless _tmp 10243 self.pos = _save 10244 end 10245 break 10246 end # end sequence 10247 10248 set_failed_rule :_OneUlOpen unless _tmp 10249 return _tmp 10250 end 10251 10252 # OneUlClose = !Spacechar !Newline Inline:a "_" { a } 10253 def _OneUlClose 10254 10255 _save = self.pos 10256 while true # sequence 10257 _save1 = self.pos 10258 _tmp = apply(:_Spacechar) 10259 _tmp = _tmp ? nil : true 10260 self.pos = _save1 10261 unless _tmp 10262 self.pos = _save 10263 break 10264 end 10265 _save2 = self.pos 10266 _tmp = apply(:_Newline) 10267 _tmp = _tmp ? nil : true 10268 self.pos = _save2 10269 unless _tmp 10270 self.pos = _save 10271 break 10272 end 10273 _tmp = apply(:_Inline) 10274 a = @result 10275 unless _tmp 10276 self.pos = _save 10277 break 10278 end 10279 _tmp = match_string("_") 10280 unless _tmp 10281 self.pos = _save 10282 break 10283 end 10284 @result = begin; a ; end 10285 _tmp = true 10286 unless _tmp 10287 self.pos = _save 10288 end 10289 break 10290 end # end sequence 10291 10292 set_failed_rule :_OneUlClose unless _tmp 10293 return _tmp 10294 end 10295 10296 # EmphUl = OneUlOpen StartList:a (!OneUlClose Inline:l { a << l })* OneUlClose:l { a << l } { emphasis a.join } 10297 def _EmphUl 10298 10299 _save = self.pos 10300 while true # sequence 10301 _tmp = apply(:_OneUlOpen) 10302 unless _tmp 10303 self.pos = _save 10304 break 10305 end 10306 _tmp = apply(:_StartList) 10307 a = @result 10308 unless _tmp 10309 self.pos = _save 10310 break 10311 end 10312 while true 10313 10314 _save2 = self.pos 10315 while true # sequence 10316 _save3 = self.pos 10317 _tmp = apply(:_OneUlClose) 10318 _tmp = _tmp ? nil : true 10319 self.pos = _save3 10320 unless _tmp 10321 self.pos = _save2 10322 break 10323 end 10324 _tmp = apply(:_Inline) 10325 l = @result 10326 unless _tmp 10327 self.pos = _save2 10328 break 10329 end 10330 @result = begin; a << l ; end 10331 _tmp = true 10332 unless _tmp 10333 self.pos = _save2 10334 end 10335 break 10336 end # end sequence 10337 10338 break unless _tmp 10339 end 10340 _tmp = true 10341 unless _tmp 10342 self.pos = _save 10343 break 10344 end 10345 _tmp = apply(:_OneUlClose) 10346 l = @result 10347 unless _tmp 10348 self.pos = _save 10349 break 10350 end 10351 @result = begin; a << l ; end 10352 _tmp = true 10353 unless _tmp 10354 self.pos = _save 10355 break 10356 end 10357 @result = begin; emphasis a.join ; end 10358 _tmp = true 10359 unless _tmp 10360 self.pos = _save 10361 end 10362 break 10363 end # end sequence 10364 10365 set_failed_rule :_EmphUl unless _tmp 10366 return _tmp 10367 end 10368 10369 # Strong = (StrongStar | StrongUl) 10370 def _Strong 10371 10372 _save = self.pos 10373 while true # choice 10374 _tmp = apply(:_StrongStar) 10375 break if _tmp 10376 self.pos = _save 10377 _tmp = apply(:_StrongUl) 10378 break if _tmp 10379 self.pos = _save 10380 break 10381 end # end choice 10382 10383 set_failed_rule :_Strong unless _tmp 10384 return _tmp 10385 end 10386 10387 # TwoStarOpen = !StarLine "**" !Spacechar !Newline 10388 def _TwoStarOpen 10389 10390 _save = self.pos 10391 while true # sequence 10392 _save1 = self.pos 10393 _tmp = apply(:_StarLine) 10394 _tmp = _tmp ? nil : true 10395 self.pos = _save1 10396 unless _tmp 10397 self.pos = _save 10398 break 10399 end 10400 _tmp = match_string("**") 10401 unless _tmp 10402 self.pos = _save 10403 break 10404 end 10405 _save2 = self.pos 10406 _tmp = apply(:_Spacechar) 10407 _tmp = _tmp ? nil : true 10408 self.pos = _save2 10409 unless _tmp 10410 self.pos = _save 10411 break 10412 end 10413 _save3 = self.pos 10414 _tmp = apply(:_Newline) 10415 _tmp = _tmp ? nil : true 10416 self.pos = _save3 10417 unless _tmp 10418 self.pos = _save 10419 end 10420 break 10421 end # end sequence 10422 10423 set_failed_rule :_TwoStarOpen unless _tmp 10424 return _tmp 10425 end 10426 10427 # TwoStarClose = !Spacechar !Newline Inline:a "**" { a } 10428 def _TwoStarClose 10429 10430 _save = self.pos 10431 while true # sequence 10432 _save1 = self.pos 10433 _tmp = apply(:_Spacechar) 10434 _tmp = _tmp ? nil : true 10435 self.pos = _save1 10436 unless _tmp 10437 self.pos = _save 10438 break 10439 end 10440 _save2 = self.pos 10441 _tmp = apply(:_Newline) 10442 _tmp = _tmp ? nil : true 10443 self.pos = _save2 10444 unless _tmp 10445 self.pos = _save 10446 break 10447 end 10448 _tmp = apply(:_Inline) 10449 a = @result 10450 unless _tmp 10451 self.pos = _save 10452 break 10453 end 10454 _tmp = match_string("**") 10455 unless _tmp 10456 self.pos = _save 10457 break 10458 end 10459 @result = begin; a ; end 10460 _tmp = true 10461 unless _tmp 10462 self.pos = _save 10463 end 10464 break 10465 end # end sequence 10466 10467 set_failed_rule :_TwoStarClose unless _tmp 10468 return _tmp 10469 end 10470 10471 # StrongStar = TwoStarOpen StartList:a (!TwoStarClose Inline:l { a << l })* TwoStarClose:l { a << l } { strong a.join } 10472 def _StrongStar 10473 10474 _save = self.pos 10475 while true # sequence 10476 _tmp = apply(:_TwoStarOpen) 10477 unless _tmp 10478 self.pos = _save 10479 break 10480 end 10481 _tmp = apply(:_StartList) 10482 a = @result 10483 unless _tmp 10484 self.pos = _save 10485 break 10486 end 10487 while true 10488 10489 _save2 = self.pos 10490 while true # sequence 10491 _save3 = self.pos 10492 _tmp = apply(:_TwoStarClose) 10493 _tmp = _tmp ? nil : true 10494 self.pos = _save3 10495 unless _tmp 10496 self.pos = _save2 10497 break 10498 end 10499 _tmp = apply(:_Inline) 10500 l = @result 10501 unless _tmp 10502 self.pos = _save2 10503 break 10504 end 10505 @result = begin; a << l ; end 10506 _tmp = true 10507 unless _tmp 10508 self.pos = _save2 10509 end 10510 break 10511 end # end sequence 10512 10513 break unless _tmp 10514 end 10515 _tmp = true 10516 unless _tmp 10517 self.pos = _save 10518 break 10519 end 10520 _tmp = apply(:_TwoStarClose) 10521 l = @result 10522 unless _tmp 10523 self.pos = _save 10524 break 10525 end 10526 @result = begin; a << l ; end 10527 _tmp = true 10528 unless _tmp 10529 self.pos = _save 10530 break 10531 end 10532 @result = begin; strong a.join ; end 10533 _tmp = true 10534 unless _tmp 10535 self.pos = _save 10536 end 10537 break 10538 end # end sequence 10539 10540 set_failed_rule :_StrongStar unless _tmp 10541 return _tmp 10542 end 10543 10544 # TwoUlOpen = !UlLine "__" !Spacechar !Newline 10545 def _TwoUlOpen 10546 10547 _save = self.pos 10548 while true # sequence 10549 _save1 = self.pos 10550 _tmp = apply(:_UlLine) 10551 _tmp = _tmp ? nil : true 10552 self.pos = _save1 10553 unless _tmp 10554 self.pos = _save 10555 break 10556 end 10557 _tmp = match_string("__") 10558 unless _tmp 10559 self.pos = _save 10560 break 10561 end 10562 _save2 = self.pos 10563 _tmp = apply(:_Spacechar) 10564 _tmp = _tmp ? nil : true 10565 self.pos = _save2 10566 unless _tmp 10567 self.pos = _save 10568 break 10569 end 10570 _save3 = self.pos 10571 _tmp = apply(:_Newline) 10572 _tmp = _tmp ? nil : true 10573 self.pos = _save3 10574 unless _tmp 10575 self.pos = _save 10576 end 10577 break 10578 end # end sequence 10579 10580 set_failed_rule :_TwoUlOpen unless _tmp 10581 return _tmp 10582 end 10583 10584 # TwoUlClose = !Spacechar !Newline Inline:a "__" { a } 10585 def _TwoUlClose 10586 10587 _save = self.pos 10588 while true # sequence 10589 _save1 = self.pos 10590 _tmp = apply(:_Spacechar) 10591 _tmp = _tmp ? nil : true 10592 self.pos = _save1 10593 unless _tmp 10594 self.pos = _save 10595 break 10596 end 10597 _save2 = self.pos 10598 _tmp = apply(:_Newline) 10599 _tmp = _tmp ? nil : true 10600 self.pos = _save2 10601 unless _tmp 10602 self.pos = _save 10603 break 10604 end 10605 _tmp = apply(:_Inline) 10606 a = @result 10607 unless _tmp 10608 self.pos = _save 10609 break 10610 end 10611 _tmp = match_string("__") 10612 unless _tmp 10613 self.pos = _save 10614 break 10615 end 10616 @result = begin; a ; end 10617 _tmp = true 10618 unless _tmp 10619 self.pos = _save 10620 end 10621 break 10622 end # end sequence 10623 10624 set_failed_rule :_TwoUlClose unless _tmp 10625 return _tmp 10626 end 10627 10628 # StrongUl = TwoUlOpen StartList:a (!TwoUlClose Inline:i { a << i })* TwoUlClose:l { a << l } { strong a.join } 10629 def _StrongUl 10630 10631 _save = self.pos 10632 while true # sequence 10633 _tmp = apply(:_TwoUlOpen) 10634 unless _tmp 10635 self.pos = _save 10636 break 10637 end 10638 _tmp = apply(:_StartList) 10639 a = @result 10640 unless _tmp 10641 self.pos = _save 10642 break 10643 end 10644 while true 10645 10646 _save2 = self.pos 10647 while true # sequence 10648 _save3 = self.pos 10649 _tmp = apply(:_TwoUlClose) 10650 _tmp = _tmp ? nil : true 10651 self.pos = _save3 10652 unless _tmp 10653 self.pos = _save2 10654 break 10655 end 10656 _tmp = apply(:_Inline) 10657 i = @result 10658 unless _tmp 10659 self.pos = _save2 10660 break 10661 end 10662 @result = begin; a << i ; end 10663 _tmp = true 10664 unless _tmp 10665 self.pos = _save2 10666 end 10667 break 10668 end # end sequence 10669 10670 break unless _tmp 10671 end 10672 _tmp = true 10673 unless _tmp 10674 self.pos = _save 10675 break 10676 end 10677 _tmp = apply(:_TwoUlClose) 10678 l = @result 10679 unless _tmp 10680 self.pos = _save 10681 break 10682 end 10683 @result = begin; a << l ; end 10684 _tmp = true 10685 unless _tmp 10686 self.pos = _save 10687 break 10688 end 10689 @result = begin; strong a.join ; end 10690 _tmp = true 10691 unless _tmp 10692 self.pos = _save 10693 end 10694 break 10695 end # end sequence 10696 10697 set_failed_rule :_StrongUl unless _tmp 10698 return _tmp 10699 end 10700 10701 # Image = "!" (ExplicitLink | ReferenceLink):a { a } 10702 def _Image 10703 10704 _save = self.pos 10705 while true # sequence 10706 _tmp = match_string("!") 10707 unless _tmp 10708 self.pos = _save 10709 break 10710 end 10711 10712 _save1 = self.pos 10713 while true # choice 10714 _tmp = apply(:_ExplicitLink) 10715 break if _tmp 10716 self.pos = _save1 10717 _tmp = apply(:_ReferenceLink) 10718 break if _tmp 10719 self.pos = _save1 10720 break 10721 end # end choice 10722 10723 a = @result 10724 unless _tmp 10725 self.pos = _save 10726 break 10727 end 10728 @result = begin; a ; end 10729 _tmp = true 10730 unless _tmp 10731 self.pos = _save 10732 end 10733 break 10734 end # end sequence 10735 10736 set_failed_rule :_Image unless _tmp 10737 return _tmp 10738 end 10739 10740 # Link = (ExplicitLink | ReferenceLink | AutoLink) 10741 def _Link 10742 10743 _save = self.pos 10744 while true # choice 10745 _tmp = apply(:_ExplicitLink) 10746 break if _tmp 10747 self.pos = _save 10748 _tmp = apply(:_ReferenceLink) 10749 break if _tmp 10750 self.pos = _save 10751 _tmp = apply(:_AutoLink) 10752 break if _tmp 10753 self.pos = _save 10754 break 10755 end # end choice 10756 10757 set_failed_rule :_Link unless _tmp 10758 return _tmp 10759 end 10760 10761 # ReferenceLink = (ReferenceLinkDouble | ReferenceLinkSingle) 10762 def _ReferenceLink 10763 10764 _save = self.pos 10765 while true # choice 10766 _tmp = apply(:_ReferenceLinkDouble) 10767 break if _tmp 10768 self.pos = _save 10769 _tmp = apply(:_ReferenceLinkSingle) 10770 break if _tmp 10771 self.pos = _save 10772 break 10773 end # end choice 10774 10775 set_failed_rule :_ReferenceLink unless _tmp 10776 return _tmp 10777 end 10778 10779 # ReferenceLinkDouble = Label:content < Spnl > !"[]" Label:label { link_to content, label, text } 10780 def _ReferenceLinkDouble 10781 10782 _save = self.pos 10783 while true # sequence 10784 _tmp = apply(:_Label) 10785 content = @result 10786 unless _tmp 10787 self.pos = _save 10788 break 10789 end 10790 _text_start = self.pos 10791 _tmp = apply(:_Spnl) 10792 if _tmp 10793 text = get_text(_text_start) 10794 end 10795 unless _tmp 10796 self.pos = _save 10797 break 10798 end 10799 _save1 = self.pos 10800 _tmp = match_string("[]") 10801 _tmp = _tmp ? nil : true 10802 self.pos = _save1 10803 unless _tmp 10804 self.pos = _save 10805 break 10806 end 10807 _tmp = apply(:_Label) 10808 label = @result 10809 unless _tmp 10810 self.pos = _save 10811 break 10812 end 10813 @result = begin; link_to content, label, text ; end 10814 _tmp = true 10815 unless _tmp 10816 self.pos = _save 10817 end 10818 break 10819 end # end sequence 10820 10821 set_failed_rule :_ReferenceLinkDouble unless _tmp 10822 return _tmp 10823 end 10824 10825 # ReferenceLinkSingle = Label:content < (Spnl "[]")? > { link_to content, content, text } 10826 def _ReferenceLinkSingle 10827 10828 _save = self.pos 10829 while true # sequence 10830 _tmp = apply(:_Label) 10831 content = @result 10832 unless _tmp 10833 self.pos = _save 10834 break 10835 end 10836 _text_start = self.pos 10837 _save1 = self.pos 10838 10839 _save2 = self.pos 10840 while true # sequence 10841 _tmp = apply(:_Spnl) 10842 unless _tmp 10843 self.pos = _save2 10844 break 10845 end 10846 _tmp = match_string("[]") 10847 unless _tmp 10848 self.pos = _save2 10849 end 10850 break 10851 end # end sequence 10852 10853 unless _tmp 10854 _tmp = true 10855 self.pos = _save1 10856 end 10857 if _tmp 10858 text = get_text(_text_start) 10859 end 10860 unless _tmp 10861 self.pos = _save 10862 break 10863 end 10864 @result = begin; link_to content, content, text ; end 10865 _tmp = true 10866 unless _tmp 10867 self.pos = _save 10868 end 10869 break 10870 end # end sequence 10871 10872 set_failed_rule :_ReferenceLinkSingle unless _tmp 10873 return _tmp 10874 end 10875 10876 # ExplicitLink = Label:l Spnl "(" Sp Source:s Spnl Title Sp ")" { "{#{l}}[#{s}]" } 10877 def _ExplicitLink 10878 10879 _save = self.pos 10880 while true # sequence 10881 _tmp = apply(:_Label) 10882 l = @result 10883 unless _tmp 10884 self.pos = _save 10885 break 10886 end 10887 _tmp = apply(:_Spnl) 10888 unless _tmp 10889 self.pos = _save 10890 break 10891 end 10892 _tmp = match_string("(") 10893 unless _tmp 10894 self.pos = _save 10895 break 10896 end 10897 _tmp = apply(:_Sp) 10898 unless _tmp 10899 self.pos = _save 10900 break 10901 end 10902 _tmp = apply(:_Source) 10903 s = @result 10904 unless _tmp 10905 self.pos = _save 10906 break 10907 end 10908 _tmp = apply(:_Spnl) 10909 unless _tmp 10910 self.pos = _save 10911 break 10912 end 10913 _tmp = apply(:_Title) 10914 unless _tmp 10915 self.pos = _save 10916 break 10917 end 10918 _tmp = apply(:_Sp) 10919 unless _tmp 10920 self.pos = _save 10921 break 10922 end 10923 _tmp = match_string(")") 10924 unless _tmp 10925 self.pos = _save 10926 break 10927 end 10928 @result = begin; "{#{l}}[#{s}]" ; end 10929 _tmp = true 10930 unless _tmp 10931 self.pos = _save 10932 end 10933 break 10934 end # end sequence 10935 10936 set_failed_rule :_ExplicitLink unless _tmp 10937 return _tmp 10938 end 10939 10940 # Source = ("<" < SourceContents > ">" | < SourceContents >) { text } 10941 def _Source 10942 10943 _save = self.pos 10944 while true # sequence 10945 10946 _save1 = self.pos 10947 while true # choice 10948 10949 _save2 = self.pos 10950 while true # sequence 10951 _tmp = match_string("<") 10952 unless _tmp 10953 self.pos = _save2 10954 break 10955 end 10956 _text_start = self.pos 10957 _tmp = apply(:_SourceContents) 10958 if _tmp 10959 text = get_text(_text_start) 10960 end 10961 unless _tmp 10962 self.pos = _save2 10963 break 10964 end 10965 _tmp = match_string(">") 10966 unless _tmp 10967 self.pos = _save2 10968 end 10969 break 10970 end # end sequence 10971 10972 break if _tmp 10973 self.pos = _save1 10974 _text_start = self.pos 10975 _tmp = apply(:_SourceContents) 10976 if _tmp 10977 text = get_text(_text_start) 10978 end 10979 break if _tmp 10980 self.pos = _save1 10981 break 10982 end # end choice 10983 10984 unless _tmp 10985 self.pos = _save 10986 break 10987 end 10988 @result = begin; text ; end 10989 _tmp = true 10990 unless _tmp 10991 self.pos = _save 10992 end 10993 break 10994 end # end sequence 10995 10996 set_failed_rule :_Source unless _tmp 10997 return _tmp 10998 end 10999 11000 # SourceContents = (((!"(" !")" !">" Nonspacechar)+ | "(" SourceContents ")")* | "") 11001 def _SourceContents 11002 11003 _save = self.pos 11004 while true # choice 11005 while true 11006 11007 _save2 = self.pos 11008 while true # choice 11009 _save3 = self.pos 11010 11011 _save4 = self.pos 11012 while true # sequence 11013 _save5 = self.pos 11014 _tmp = match_string("(") 11015 _tmp = _tmp ? nil : true 11016 self.pos = _save5 11017 unless _tmp 11018 self.pos = _save4 11019 break 11020 end 11021 _save6 = self.pos 11022 _tmp = match_string(")") 11023 _tmp = _tmp ? nil : true 11024 self.pos = _save6 11025 unless _tmp 11026 self.pos = _save4 11027 break 11028 end 11029 _save7 = self.pos 11030 _tmp = match_string(">") 11031 _tmp = _tmp ? nil : true 11032 self.pos = _save7 11033 unless _tmp 11034 self.pos = _save4 11035 break 11036 end 11037 _tmp = apply(:_Nonspacechar) 11038 unless _tmp 11039 self.pos = _save4 11040 end 11041 break 11042 end # end sequence 11043 11044 if _tmp 11045 while true 11046 11047 _save8 = self.pos 11048 while true # sequence 11049 _save9 = self.pos 11050 _tmp = match_string("(") 11051 _tmp = _tmp ? nil : true 11052 self.pos = _save9 11053 unless _tmp 11054 self.pos = _save8 11055 break 11056 end 11057 _save10 = self.pos 11058 _tmp = match_string(")") 11059 _tmp = _tmp ? nil : true 11060 self.pos = _save10 11061 unless _tmp 11062 self.pos = _save8 11063 break 11064 end 11065 _save11 = self.pos 11066 _tmp = match_string(">") 11067 _tmp = _tmp ? nil : true 11068 self.pos = _save11 11069 unless _tmp 11070 self.pos = _save8 11071 break 11072 end 11073 _tmp = apply(:_Nonspacechar) 11074 unless _tmp 11075 self.pos = _save8 11076 end 11077 break 11078 end # end sequence 11079 11080 break unless _tmp 11081 end 11082 _tmp = true 11083 else 11084 self.pos = _save3 11085 end 11086 break if _tmp 11087 self.pos = _save2 11088 11089 _save12 = self.pos 11090 while true # sequence 11091 _tmp = match_string("(") 11092 unless _tmp 11093 self.pos = _save12 11094 break 11095 end 11096 _tmp = apply(:_SourceContents) 11097 unless _tmp 11098 self.pos = _save12 11099 break 11100 end 11101 _tmp = match_string(")") 11102 unless _tmp 11103 self.pos = _save12 11104 end 11105 break 11106 end # end sequence 11107 11108 break if _tmp 11109 self.pos = _save2 11110 break 11111 end # end choice 11112 11113 break unless _tmp 11114 end 11115 _tmp = true 11116 break if _tmp 11117 self.pos = _save 11118 _tmp = match_string("") 11119 break if _tmp 11120 self.pos = _save 11121 break 11122 end # end choice 11123 11124 set_failed_rule :_SourceContents unless _tmp 11125 return _tmp 11126 end 11127 11128 # Title = (TitleSingle | TitleDouble | ""):a { a } 11129 def _Title 11130 11131 _save = self.pos 11132 while true # sequence 11133 11134 _save1 = self.pos 11135 while true # choice 11136 _tmp = apply(:_TitleSingle) 11137 break if _tmp 11138 self.pos = _save1 11139 _tmp = apply(:_TitleDouble) 11140 break if _tmp 11141 self.pos = _save1 11142 _tmp = match_string("") 11143 break if _tmp 11144 self.pos = _save1 11145 break 11146 end # end choice 11147 11148 a = @result 11149 unless _tmp 11150 self.pos = _save 11151 break 11152 end 11153 @result = begin; a ; end 11154 _tmp = true 11155 unless _tmp 11156 self.pos = _save 11157 end 11158 break 11159 end # end sequence 11160 11161 set_failed_rule :_Title unless _tmp 11162 return _tmp 11163 end 11164 11165 # TitleSingle = "'" (!("'" Sp (")" | Newline)) .)* "'" 11166 def _TitleSingle 11167 11168 _save = self.pos 11169 while true # sequence 11170 _tmp = match_string("'") 11171 unless _tmp 11172 self.pos = _save 11173 break 11174 end 11175 while true 11176 11177 _save2 = self.pos 11178 while true # sequence 11179 _save3 = self.pos 11180 11181 _save4 = self.pos 11182 while true # sequence 11183 _tmp = match_string("'") 11184 unless _tmp 11185 self.pos = _save4 11186 break 11187 end 11188 _tmp = apply(:_Sp) 11189 unless _tmp 11190 self.pos = _save4 11191 break 11192 end 11193 11194 _save5 = self.pos 11195 while true # choice 11196 _tmp = match_string(")") 11197 break if _tmp 11198 self.pos = _save5 11199 _tmp = apply(:_Newline) 11200 break if _tmp 11201 self.pos = _save5 11202 break 11203 end # end choice 11204 11205 unless _tmp 11206 self.pos = _save4 11207 end 11208 break 11209 end # end sequence 11210 11211 _tmp = _tmp ? nil : true 11212 self.pos = _save3 11213 unless _tmp 11214 self.pos = _save2 11215 break 11216 end 11217 _tmp = get_byte 11218 unless _tmp 11219 self.pos = _save2 11220 end 11221 break 11222 end # end sequence 11223 11224 break unless _tmp 11225 end 11226 _tmp = true 11227 unless _tmp 11228 self.pos = _save 11229 break 11230 end 11231 _tmp = match_string("'") 11232 unless _tmp 11233 self.pos = _save 11234 end 11235 break 11236 end # end sequence 11237 11238 set_failed_rule :_TitleSingle unless _tmp 11239 return _tmp 11240 end 11241 11242 # TitleDouble = "\"" (!("\"" Sp (")" | Newline)) .)* "\"" 11243 def _TitleDouble 11244 11245 _save = self.pos 11246 while true # sequence 11247 _tmp = match_string("\"") 11248 unless _tmp 11249 self.pos = _save 11250 break 11251 end 11252 while true 11253 11254 _save2 = self.pos 11255 while true # sequence 11256 _save3 = self.pos 11257 11258 _save4 = self.pos 11259 while true # sequence 11260 _tmp = match_string("\"") 11261 unless _tmp 11262 self.pos = _save4 11263 break 11264 end 11265 _tmp = apply(:_Sp) 11266 unless _tmp 11267 self.pos = _save4 11268 break 11269 end 11270 11271 _save5 = self.pos 11272 while true # choice 11273 _tmp = match_string(")") 11274 break if _tmp 11275 self.pos = _save5 11276 _tmp = apply(:_Newline) 11277 break if _tmp 11278 self.pos = _save5 11279 break 11280 end # end choice 11281 11282 unless _tmp 11283 self.pos = _save4 11284 end 11285 break 11286 end # end sequence 11287 11288 _tmp = _tmp ? nil : true 11289 self.pos = _save3 11290 unless _tmp 11291 self.pos = _save2 11292 break 11293 end 11294 _tmp = get_byte 11295 unless _tmp 11296 self.pos = _save2 11297 end 11298 break 11299 end # end sequence 11300 11301 break unless _tmp 11302 end 11303 _tmp = true 11304 unless _tmp 11305 self.pos = _save 11306 break 11307 end 11308 _tmp = match_string("\"") 11309 unless _tmp 11310 self.pos = _save 11311 end 11312 break 11313 end # end sequence 11314 11315 set_failed_rule :_TitleDouble unless _tmp 11316 return _tmp 11317 end 11318 11319 # AutoLink = (AutoLinkUrl | AutoLinkEmail) 11320 def _AutoLink 11321 11322 _save = self.pos 11323 while true # choice 11324 _tmp = apply(:_AutoLinkUrl) 11325 break if _tmp 11326 self.pos = _save 11327 _tmp = apply(:_AutoLinkEmail) 11328 break if _tmp 11329 self.pos = _save 11330 break 11331 end # end choice 11332 11333 set_failed_rule :_AutoLink unless _tmp 11334 return _tmp 11335 end 11336 11337 # AutoLinkUrl = "<" < /[A-Za-z]+/ "://" (!Newline !">" .)+ > ">" { text } 11338 def _AutoLinkUrl 11339 11340 _save = self.pos 11341 while true # sequence 11342 _tmp = match_string("<") 11343 unless _tmp 11344 self.pos = _save 11345 break 11346 end 11347 _text_start = self.pos 11348 11349 _save1 = self.pos 11350 while true # sequence 11351 _tmp = scan(/\A(?-mix:[A-Za-z]+)/) 11352 unless _tmp 11353 self.pos = _save1 11354 break 11355 end 11356 _tmp = match_string("://") 11357 unless _tmp 11358 self.pos = _save1 11359 break 11360 end 11361 _save2 = self.pos 11362 11363 _save3 = self.pos 11364 while true # sequence 11365 _save4 = self.pos 11366 _tmp = apply(:_Newline) 11367 _tmp = _tmp ? nil : true 11368 self.pos = _save4 11369 unless _tmp 11370 self.pos = _save3 11371 break 11372 end 11373 _save5 = self.pos 11374 _tmp = match_string(">") 11375 _tmp = _tmp ? nil : true 11376 self.pos = _save5 11377 unless _tmp 11378 self.pos = _save3 11379 break 11380 end 11381 _tmp = get_byte 11382 unless _tmp 11383 self.pos = _save3 11384 end 11385 break 11386 end # end sequence 11387 11388 if _tmp 11389 while true 11390 11391 _save6 = self.pos 11392 while true # sequence 11393 _save7 = self.pos 11394 _tmp = apply(:_Newline) 11395 _tmp = _tmp ? nil : true 11396 self.pos = _save7 11397 unless _tmp 11398 self.pos = _save6 11399 break 11400 end 11401 _save8 = self.pos 11402 _tmp = match_string(">") 11403 _tmp = _tmp ? nil : true 11404 self.pos = _save8 11405 unless _tmp 11406 self.pos = _save6 11407 break 11408 end 11409 _tmp = get_byte 11410 unless _tmp 11411 self.pos = _save6 11412 end 11413 break 11414 end # end sequence 11415 11416 break unless _tmp 11417 end 11418 _tmp = true 11419 else 11420 self.pos = _save2 11421 end 11422 unless _tmp 11423 self.pos = _save1 11424 end 11425 break 11426 end # end sequence 11427 11428 if _tmp 11429 text = get_text(_text_start) 11430 end 11431 unless _tmp 11432 self.pos = _save 11433 break 11434 end 11435 _tmp = match_string(">") 11436 unless _tmp 11437 self.pos = _save 11438 break 11439 end 11440 @result = begin; text ; end 11441 _tmp = true 11442 unless _tmp 11443 self.pos = _save 11444 end 11445 break 11446 end # end sequence 11447 11448 set_failed_rule :_AutoLinkUrl unless _tmp 11449 return _tmp 11450 end 11451 11452 # AutoLinkEmail = "<" "mailto:"? < /[\w+.\/!%~$-]+/i "@" (!Newline !">" .)+ > ">" { "mailto:#{text}" } 11453 def _AutoLinkEmail 11454 11455 _save = self.pos 11456 while true # sequence 11457 _tmp = match_string("<") 11458 unless _tmp 11459 self.pos = _save 11460 break 11461 end 11462 _save1 = self.pos 11463 _tmp = match_string("mailto:") 11464 unless _tmp 11465 _tmp = true 11466 self.pos = _save1 11467 end 11468 unless _tmp 11469 self.pos = _save 11470 break 11471 end 11472 _text_start = self.pos 11473 11474 _save2 = self.pos 11475 while true # sequence 11476 _tmp = scan(/\A(?i-mx:[\w+.\/!%~$-]+)/) 11477 unless _tmp 11478 self.pos = _save2 11479 break 11480 end 11481 _tmp = match_string("@") 11482 unless _tmp 11483 self.pos = _save2 11484 break 11485 end 11486 _save3 = self.pos 11487 11488 _save4 = self.pos 11489 while true # sequence 11490 _save5 = self.pos 11491 _tmp = apply(:_Newline) 11492 _tmp = _tmp ? nil : true 11493 self.pos = _save5 11494 unless _tmp 11495 self.pos = _save4 11496 break 11497 end 11498 _save6 = self.pos 11499 _tmp = match_string(">") 11500 _tmp = _tmp ? nil : true 11501 self.pos = _save6 11502 unless _tmp 11503 self.pos = _save4 11504 break 11505 end 11506 _tmp = get_byte 11507 unless _tmp 11508 self.pos = _save4 11509 end 11510 break 11511 end # end sequence 11512 11513 if _tmp 11514 while true 11515 11516 _save7 = self.pos 11517 while true # sequence 11518 _save8 = self.pos 11519 _tmp = apply(:_Newline) 11520 _tmp = _tmp ? nil : true 11521 self.pos = _save8 11522 unless _tmp 11523 self.pos = _save7 11524 break 11525 end 11526 _save9 = self.pos 11527 _tmp = match_string(">") 11528 _tmp = _tmp ? nil : true 11529 self.pos = _save9 11530 unless _tmp 11531 self.pos = _save7 11532 break 11533 end 11534 _tmp = get_byte 11535 unless _tmp 11536 self.pos = _save7 11537 end 11538 break 11539 end # end sequence 11540 11541 break unless _tmp 11542 end 11543 _tmp = true 11544 else 11545 self.pos = _save3 11546 end 11547 unless _tmp 11548 self.pos = _save2 11549 end 11550 break 11551 end # end sequence 11552 11553 if _tmp 11554 text = get_text(_text_start) 11555 end 11556 unless _tmp 11557 self.pos = _save 11558 break 11559 end 11560 _tmp = match_string(">") 11561 unless _tmp 11562 self.pos = _save 11563 break 11564 end 11565 @result = begin; "mailto:#{text}" ; end 11566 _tmp = true 11567 unless _tmp 11568 self.pos = _save 11569 end 11570 break 11571 end # end sequence 11572 11573 set_failed_rule :_AutoLinkEmail unless _tmp 11574 return _tmp 11575 end 11576 11577 # Reference = NonindentSpace !"[]" Label:label ":" Spnl RefSrc:link RefTitle BlankLine+ { # TODO use title reference label, link nil } 11578 def _Reference 11579 11580 _save = self.pos 11581 while true # sequence 11582 _tmp = apply(:_NonindentSpace) 11583 unless _tmp 11584 self.pos = _save 11585 break 11586 end 11587 _save1 = self.pos 11588 _tmp = match_string("[]") 11589 _tmp = _tmp ? nil : true 11590 self.pos = _save1 11591 unless _tmp 11592 self.pos = _save 11593 break 11594 end 11595 _tmp = apply(:_Label) 11596 label = @result 11597 unless _tmp 11598 self.pos = _save 11599 break 11600 end 11601 _tmp = match_string(":") 11602 unless _tmp 11603 self.pos = _save 11604 break 11605 end 11606 _tmp = apply(:_Spnl) 11607 unless _tmp 11608 self.pos = _save 11609 break 11610 end 11611 _tmp = apply(:_RefSrc) 11612 link = @result 11613 unless _tmp 11614 self.pos = _save 11615 break 11616 end 11617 _tmp = apply(:_RefTitle) 11618 unless _tmp 11619 self.pos = _save 11620 break 11621 end 11622 _save2 = self.pos 11623 _tmp = apply(:_BlankLine) 11624 if _tmp 11625 while true 11626 _tmp = apply(:_BlankLine) 11627 break unless _tmp 11628 end 11629 _tmp = true 11630 else 11631 self.pos = _save2 11632 end 11633 unless _tmp 11634 self.pos = _save 11635 break 11636 end 11637 @result = begin; # TODO use title 11638 reference label, link 11639 nil 11640 ; end 11641 _tmp = true 11642 unless _tmp 11643 self.pos = _save 11644 end 11645 break 11646 end # end sequence 11647 11648 set_failed_rule :_Reference unless _tmp 11649 return _tmp 11650 end 11651 11652 # Label = "[" (!"^" &{ notes? } | &. &{ !notes? }) StartList:a (!"]" Inline:l { a << l })* "]" { a.join.gsub(/\s+/, ' ') } 11653 def _Label 11654 11655 _save = self.pos 11656 while true # sequence 11657 _tmp = match_string("[") 11658 unless _tmp 11659 self.pos = _save 11660 break 11661 end 11662 11663 _save1 = self.pos 11664 while true # choice 11665 11666 _save2 = self.pos 11667 while true # sequence 11668 _save3 = self.pos 11669 _tmp = match_string("^") 11670 _tmp = _tmp ? nil : true 11671 self.pos = _save3 11672 unless _tmp 11673 self.pos = _save2 11674 break 11675 end 11676 _save4 = self.pos 11677 _tmp = begin; notes? ; end 11678 self.pos = _save4 11679 unless _tmp 11680 self.pos = _save2 11681 end 11682 break 11683 end # end sequence 11684 11685 break if _tmp 11686 self.pos = _save1 11687 11688 _save5 = self.pos 11689 while true # sequence 11690 _save6 = self.pos 11691 _tmp = get_byte 11692 self.pos = _save6 11693 unless _tmp 11694 self.pos = _save5 11695 break 11696 end 11697 _save7 = self.pos 11698 _tmp = begin; !notes? ; end 11699 self.pos = _save7 11700 unless _tmp 11701 self.pos = _save5 11702 end 11703 break 11704 end # end sequence 11705 11706 break if _tmp 11707 self.pos = _save1 11708 break 11709 end # end choice 11710 11711 unless _tmp 11712 self.pos = _save 11713 break 11714 end 11715 _tmp = apply(:_StartList) 11716 a = @result 11717 unless _tmp 11718 self.pos = _save 11719 break 11720 end 11721 while true 11722 11723 _save9 = self.pos 11724 while true # sequence 11725 _save10 = self.pos 11726 _tmp = match_string("]") 11727 _tmp = _tmp ? nil : true 11728 self.pos = _save10 11729 unless _tmp 11730 self.pos = _save9 11731 break 11732 end 11733 _tmp = apply(:_Inline) 11734 l = @result 11735 unless _tmp 11736 self.pos = _save9 11737 break 11738 end 11739 @result = begin; a << l ; end 11740 _tmp = true 11741 unless _tmp 11742 self.pos = _save9 11743 end 11744 break 11745 end # end sequence 11746 11747 break unless _tmp 11748 end 11749 _tmp = true 11750 unless _tmp 11751 self.pos = _save 11752 break 11753 end 11754 _tmp = match_string("]") 11755 unless _tmp 11756 self.pos = _save 11757 break 11758 end 11759 @result = begin; a.join.gsub(/\s+/, ' ') ; end 11760 _tmp = true 11761 unless _tmp 11762 self.pos = _save 11763 end 11764 break 11765 end # end sequence 11766 11767 set_failed_rule :_Label unless _tmp 11768 return _tmp 11769 end 11770 11771 # RefSrc = < Nonspacechar+ > { text } 11772 def _RefSrc 11773 11774 _save = self.pos 11775 while true # sequence 11776 _text_start = self.pos 11777 _save1 = self.pos 11778 _tmp = apply(:_Nonspacechar) 11779 if _tmp 11780 while true 11781 _tmp = apply(:_Nonspacechar) 11782 break unless _tmp 11783 end 11784 _tmp = true 11785 else 11786 self.pos = _save1 11787 end 11788 if _tmp 11789 text = get_text(_text_start) 11790 end 11791 unless _tmp 11792 self.pos = _save 11793 break 11794 end 11795 @result = begin; text ; end 11796 _tmp = true 11797 unless _tmp 11798 self.pos = _save 11799 end 11800 break 11801 end # end sequence 11802 11803 set_failed_rule :_RefSrc unless _tmp 11804 return _tmp 11805 end 11806 11807 # RefTitle = (RefTitleSingle | RefTitleDouble | RefTitleParens | EmptyTitle) 11808 def _RefTitle 11809 11810 _save = self.pos 11811 while true # choice 11812 _tmp = apply(:_RefTitleSingle) 11813 break if _tmp 11814 self.pos = _save 11815 _tmp = apply(:_RefTitleDouble) 11816 break if _tmp 11817 self.pos = _save 11818 _tmp = apply(:_RefTitleParens) 11819 break if _tmp 11820 self.pos = _save 11821 _tmp = apply(:_EmptyTitle) 11822 break if _tmp 11823 self.pos = _save 11824 break 11825 end # end choice 11826 11827 set_failed_rule :_RefTitle unless _tmp 11828 return _tmp 11829 end 11830 11831 # EmptyTitle = "" 11832 def _EmptyTitle 11833 _tmp = match_string("") 11834 set_failed_rule :_EmptyTitle unless _tmp 11835 return _tmp 11836 end 11837 11838 # RefTitleSingle = Spnl "'" < (!("'" Sp Newline | Newline) .)* > "'" { text } 11839 def _RefTitleSingle 11840 11841 _save = self.pos 11842 while true # sequence 11843 _tmp = apply(:_Spnl) 11844 unless _tmp 11845 self.pos = _save 11846 break 11847 end 11848 _tmp = match_string("'") 11849 unless _tmp 11850 self.pos = _save 11851 break 11852 end 11853 _text_start = self.pos 11854 while true 11855 11856 _save2 = self.pos 11857 while true # sequence 11858 _save3 = self.pos 11859 11860 _save4 = self.pos 11861 while true # choice 11862 11863 _save5 = self.pos 11864 while true # sequence 11865 _tmp = match_string("'") 11866 unless _tmp 11867 self.pos = _save5 11868 break 11869 end 11870 _tmp = apply(:_Sp) 11871 unless _tmp 11872 self.pos = _save5 11873 break 11874 end 11875 _tmp = apply(:_Newline) 11876 unless _tmp 11877 self.pos = _save5 11878 end 11879 break 11880 end # end sequence 11881 11882 break if _tmp 11883 self.pos = _save4 11884 _tmp = apply(:_Newline) 11885 break if _tmp 11886 self.pos = _save4 11887 break 11888 end # end choice 11889 11890 _tmp = _tmp ? nil : true 11891 self.pos = _save3 11892 unless _tmp 11893 self.pos = _save2 11894 break 11895 end 11896 _tmp = get_byte 11897 unless _tmp 11898 self.pos = _save2 11899 end 11900 break 11901 end # end sequence 11902 11903 break unless _tmp 11904 end 11905 _tmp = true 11906 if _tmp 11907 text = get_text(_text_start) 11908 end 11909 unless _tmp 11910 self.pos = _save 11911 break 11912 end 11913 _tmp = match_string("'") 11914 unless _tmp 11915 self.pos = _save 11916 break 11917 end 11918 @result = begin; text ; end 11919 _tmp = true 11920 unless _tmp 11921 self.pos = _save 11922 end 11923 break 11924 end # end sequence 11925 11926 set_failed_rule :_RefTitleSingle unless _tmp 11927 return _tmp 11928 end 11929 11930 # RefTitleDouble = Spnl "\"" < (!("\"" Sp Newline | Newline) .)* > "\"" { text } 11931 def _RefTitleDouble 11932 11933 _save = self.pos 11934 while true # sequence 11935 _tmp = apply(:_Spnl) 11936 unless _tmp 11937 self.pos = _save 11938 break 11939 end 11940 _tmp = match_string("\"") 11941 unless _tmp 11942 self.pos = _save 11943 break 11944 end 11945 _text_start = self.pos 11946 while true 11947 11948 _save2 = self.pos 11949 while true # sequence 11950 _save3 = self.pos 11951 11952 _save4 = self.pos 11953 while true # choice 11954 11955 _save5 = self.pos 11956 while true # sequence 11957 _tmp = match_string("\"") 11958 unless _tmp 11959 self.pos = _save5 11960 break 11961 end 11962 _tmp = apply(:_Sp) 11963 unless _tmp 11964 self.pos = _save5 11965 break 11966 end 11967 _tmp = apply(:_Newline) 11968 unless _tmp 11969 self.pos = _save5 11970 end 11971 break 11972 end # end sequence 11973 11974 break if _tmp 11975 self.pos = _save4 11976 _tmp = apply(:_Newline) 11977 break if _tmp 11978 self.pos = _save4 11979 break 11980 end # end choice 11981 11982 _tmp = _tmp ? nil : true 11983 self.pos = _save3 11984 unless _tmp 11985 self.pos = _save2 11986 break 11987 end 11988 _tmp = get_byte 11989 unless _tmp 11990 self.pos = _save2 11991 end 11992 break 11993 end # end sequence 11994 11995 break unless _tmp 11996 end 11997 _tmp = true 11998 if _tmp 11999 text = get_text(_text_start) 12000 end 12001 unless _tmp 12002 self.pos = _save 12003 break 12004 end 12005 _tmp = match_string("\"") 12006 unless _tmp 12007 self.pos = _save 12008 break 12009 end 12010 @result = begin; text ; end 12011 _tmp = true 12012 unless _tmp 12013 self.pos = _save 12014 end 12015 break 12016 end # end sequence 12017 12018 set_failed_rule :_RefTitleDouble unless _tmp 12019 return _tmp 12020 end 12021 12022 # RefTitleParens = Spnl "(" < (!(")" Sp Newline | Newline) .)* > ")" { text } 12023 def _RefTitleParens 12024 12025 _save = self.pos 12026 while true # sequence 12027 _tmp = apply(:_Spnl) 12028 unless _tmp 12029 self.pos = _save 12030 break 12031 end 12032 _tmp = match_string("(") 12033 unless _tmp 12034 self.pos = _save 12035 break 12036 end 12037 _text_start = self.pos 12038 while true 12039 12040 _save2 = self.pos 12041 while true # sequence 12042 _save3 = self.pos 12043 12044 _save4 = self.pos 12045 while true # choice 12046 12047 _save5 = self.pos 12048 while true # sequence 12049 _tmp = match_string(")") 12050 unless _tmp 12051 self.pos = _save5 12052 break 12053 end 12054 _tmp = apply(:_Sp) 12055 unless _tmp 12056 self.pos = _save5 12057 break 12058 end 12059 _tmp = apply(:_Newline) 12060 unless _tmp 12061 self.pos = _save5 12062 end 12063 break 12064 end # end sequence 12065 12066 break if _tmp 12067 self.pos = _save4 12068 _tmp = apply(:_Newline) 12069 break if _tmp 12070 self.pos = _save4 12071 break 12072 end # end choice 12073 12074 _tmp = _tmp ? nil : true 12075 self.pos = _save3 12076 unless _tmp 12077 self.pos = _save2 12078 break 12079 end 12080 _tmp = get_byte 12081 unless _tmp 12082 self.pos = _save2 12083 end 12084 break 12085 end # end sequence 12086 12087 break unless _tmp 12088 end 12089 _tmp = true 12090 if _tmp 12091 text = get_text(_text_start) 12092 end 12093 unless _tmp 12094 self.pos = _save 12095 break 12096 end 12097 _tmp = match_string(")") 12098 unless _tmp 12099 self.pos = _save 12100 break 12101 end 12102 @result = begin; text ; end 12103 _tmp = true 12104 unless _tmp 12105 self.pos = _save 12106 end 12107 break 12108 end # end sequence 12109 12110 set_failed_rule :_RefTitleParens unless _tmp 12111 return _tmp 12112 end 12113 12114 # References = (Reference | SkipBlock)* 12115 def _References 12116 while true 12117 12118 _save1 = self.pos 12119 while true # choice 12120 _tmp = apply(:_Reference) 12121 break if _tmp 12122 self.pos = _save1 12123 _tmp = apply(:_SkipBlock) 12124 break if _tmp 12125 self.pos = _save1 12126 break 12127 end # end choice 12128 12129 break unless _tmp 12130 end 12131 _tmp = true 12132 set_failed_rule :_References unless _tmp 12133 return _tmp 12134 end 12135 12136 # Ticks1 = "`" !"`" 12137 def _Ticks1 12138 12139 _save = self.pos 12140 while true # sequence 12141 _tmp = match_string("`") 12142 unless _tmp 12143 self.pos = _save 12144 break 12145 end 12146 _save1 = self.pos 12147 _tmp = match_string("`") 12148 _tmp = _tmp ? nil : true 12149 self.pos = _save1 12150 unless _tmp 12151 self.pos = _save 12152 end 12153 break 12154 end # end sequence 12155 12156 set_failed_rule :_Ticks1 unless _tmp 12157 return _tmp 12158 end 12159 12160 # Ticks2 = "``" !"`" 12161 def _Ticks2 12162 12163 _save = self.pos 12164 while true # sequence 12165 _tmp = match_string("``") 12166 unless _tmp 12167 self.pos = _save 12168 break 12169 end 12170 _save1 = self.pos 12171 _tmp = match_string("`") 12172 _tmp = _tmp ? nil : true 12173 self.pos = _save1 12174 unless _tmp 12175 self.pos = _save 12176 end 12177 break 12178 end # end sequence 12179 12180 set_failed_rule :_Ticks2 unless _tmp 12181 return _tmp 12182 end 12183 12184 # Ticks3 = "```" !"`" 12185 def _Ticks3 12186 12187 _save = self.pos 12188 while true # sequence 12189 _tmp = match_string("```") 12190 unless _tmp 12191 self.pos = _save 12192 break 12193 end 12194 _save1 = self.pos 12195 _tmp = match_string("`") 12196 _tmp = _tmp ? nil : true 12197 self.pos = _save1 12198 unless _tmp 12199 self.pos = _save 12200 end 12201 break 12202 end # end sequence 12203 12204 set_failed_rule :_Ticks3 unless _tmp 12205 return _tmp 12206 end 12207 12208 # Ticks4 = "````" !"`" 12209 def _Ticks4 12210 12211 _save = self.pos 12212 while true # sequence 12213 _tmp = match_string("````") 12214 unless _tmp 12215 self.pos = _save 12216 break 12217 end 12218 _save1 = self.pos 12219 _tmp = match_string("`") 12220 _tmp = _tmp ? nil : true 12221 self.pos = _save1 12222 unless _tmp 12223 self.pos = _save 12224 end 12225 break 12226 end # end sequence 12227 12228 set_failed_rule :_Ticks4 unless _tmp 12229 return _tmp 12230 end 12231 12232 # Ticks5 = "`````" !"`" 12233 def _Ticks5 12234 12235 _save = self.pos 12236 while true # sequence 12237 _tmp = match_string("`````") 12238 unless _tmp 12239 self.pos = _save 12240 break 12241 end 12242 _save1 = self.pos 12243 _tmp = match_string("`") 12244 _tmp = _tmp ? nil : true 12245 self.pos = _save1 12246 unless _tmp 12247 self.pos = _save 12248 end 12249 break 12250 end # end sequence 12251 12252 set_failed_rule :_Ticks5 unless _tmp 12253 return _tmp 12254 end 12255 12256 # Code = (Ticks1 Sp < ((!"`" Nonspacechar)+ | !Ticks1 "`"+ | !(Sp Ticks1) (Spacechar | Newline !BlankLine))+ > Sp Ticks1 | Ticks2 Sp < ((!"`" Nonspacechar)+ | !Ticks2 "`"+ | !(Sp Ticks2) (Spacechar | Newline !BlankLine))+ > Sp Ticks2 | Ticks3 Sp < ((!"`" Nonspacechar)+ | !Ticks3 "`"+ | !(Sp Ticks3) (Spacechar | Newline !BlankLine))+ > Sp Ticks3 | Ticks4 Sp < ((!"`" Nonspacechar)+ | !Ticks4 "`"+ | !(Sp Ticks4) (Spacechar | Newline !BlankLine))+ > Sp Ticks4 | Ticks5 Sp < ((!"`" Nonspacechar)+ | !Ticks5 "`"+ | !(Sp Ticks5) (Spacechar | Newline !BlankLine))+ > Sp Ticks5) { "<code>#{text}</code>" } 12257 def _Code 12258 12259 _save = self.pos 12260 while true # sequence 12261 12262 _save1 = self.pos 12263 while true # choice 12264 12265 _save2 = self.pos 12266 while true # sequence 12267 _tmp = apply(:_Ticks1) 12268 unless _tmp 12269 self.pos = _save2 12270 break 12271 end 12272 _tmp = apply(:_Sp) 12273 unless _tmp 12274 self.pos = _save2 12275 break 12276 end 12277 _text_start = self.pos 12278 _save3 = self.pos 12279 12280 _save4 = self.pos 12281 while true # choice 12282 _save5 = self.pos 12283 12284 _save6 = self.pos 12285 while true # sequence 12286 _save7 = self.pos 12287 _tmp = match_string("`") 12288 _tmp = _tmp ? nil : true 12289 self.pos = _save7 12290 unless _tmp 12291 self.pos = _save6 12292 break 12293 end 12294 _tmp = apply(:_Nonspacechar) 12295 unless _tmp 12296 self.pos = _save6 12297 end 12298 break 12299 end # end sequence 12300 12301 if _tmp 12302 while true 12303 12304 _save8 = self.pos 12305 while true # sequence 12306 _save9 = self.pos 12307 _tmp = match_string("`") 12308 _tmp = _tmp ? nil : true 12309 self.pos = _save9 12310 unless _tmp 12311 self.pos = _save8 12312 break 12313 end 12314 _tmp = apply(:_Nonspacechar) 12315 unless _tmp 12316 self.pos = _save8 12317 end 12318 break 12319 end # end sequence 12320 12321 break unless _tmp 12322 end 12323 _tmp = true 12324 else 12325 self.pos = _save5 12326 end 12327 break if _tmp 12328 self.pos = _save4 12329 12330 _save10 = self.pos 12331 while true # sequence 12332 _save11 = self.pos 12333 _tmp = apply(:_Ticks1) 12334 _tmp = _tmp ? nil : true 12335 self.pos = _save11 12336 unless _tmp 12337 self.pos = _save10 12338 break 12339 end 12340 _save12 = self.pos 12341 _tmp = match_string("`") 12342 if _tmp 12343 while true 12344 _tmp = match_string("`") 12345 break unless _tmp 12346 end 12347 _tmp = true 12348 else 12349 self.pos = _save12 12350 end 12351 unless _tmp 12352 self.pos = _save10 12353 end 12354 break 12355 end # end sequence 12356 12357 break if _tmp 12358 self.pos = _save4 12359 12360 _save13 = self.pos 12361 while true # sequence 12362 _save14 = self.pos 12363 12364 _save15 = self.pos 12365 while true # sequence 12366 _tmp = apply(:_Sp) 12367 unless _tmp 12368 self.pos = _save15 12369 break 12370 end 12371 _tmp = apply(:_Ticks1) 12372 unless _tmp 12373 self.pos = _save15 12374 end 12375 break 12376 end # end sequence 12377 12378 _tmp = _tmp ? nil : true 12379 self.pos = _save14 12380 unless _tmp 12381 self.pos = _save13 12382 break 12383 end 12384 12385 _save16 = self.pos 12386 while true # choice 12387 _tmp = apply(:_Spacechar) 12388 break if _tmp 12389 self.pos = _save16 12390 12391 _save17 = self.pos 12392 while true # sequence 12393 _tmp = apply(:_Newline) 12394 unless _tmp 12395 self.pos = _save17 12396 break 12397 end 12398 _save18 = self.pos 12399 _tmp = apply(:_BlankLine) 12400 _tmp = _tmp ? nil : true 12401 self.pos = _save18 12402 unless _tmp 12403 self.pos = _save17 12404 end 12405 break 12406 end # end sequence 12407 12408 break if _tmp 12409 self.pos = _save16 12410 break 12411 end # end choice 12412 12413 unless _tmp 12414 self.pos = _save13 12415 end 12416 break 12417 end # end sequence 12418 12419 break if _tmp 12420 self.pos = _save4 12421 break 12422 end # end choice 12423 12424 if _tmp 12425 while true 12426 12427 _save19 = self.pos 12428 while true # choice 12429 _save20 = self.pos 12430 12431 _save21 = self.pos 12432 while true # sequence 12433 _save22 = self.pos 12434 _tmp = match_string("`") 12435 _tmp = _tmp ? nil : true 12436 self.pos = _save22 12437 unless _tmp 12438 self.pos = _save21 12439 break 12440 end 12441 _tmp = apply(:_Nonspacechar) 12442 unless _tmp 12443 self.pos = _save21 12444 end 12445 break 12446 end # end sequence 12447 12448 if _tmp 12449 while true 12450 12451 _save23 = self.pos 12452 while true # sequence 12453 _save24 = self.pos 12454 _tmp = match_string("`") 12455 _tmp = _tmp ? nil : true 12456 self.pos = _save24 12457 unless _tmp 12458 self.pos = _save23 12459 break 12460 end 12461 _tmp = apply(:_Nonspacechar) 12462 unless _tmp 12463 self.pos = _save23 12464 end 12465 break 12466 end # end sequence 12467 12468 break unless _tmp 12469 end 12470 _tmp = true 12471 else 12472 self.pos = _save20 12473 end 12474 break if _tmp 12475 self.pos = _save19 12476 12477 _save25 = self.pos 12478 while true # sequence 12479 _save26 = self.pos 12480 _tmp = apply(:_Ticks1) 12481 _tmp = _tmp ? nil : true 12482 self.pos = _save26 12483 unless _tmp 12484 self.pos = _save25 12485 break 12486 end 12487 _save27 = self.pos 12488 _tmp = match_string("`") 12489 if _tmp 12490 while true 12491 _tmp = match_string("`") 12492 break unless _tmp 12493 end 12494 _tmp = true 12495 else 12496 self.pos = _save27 12497 end 12498 unless _tmp 12499 self.pos = _save25 12500 end 12501 break 12502 end # end sequence 12503 12504 break if _tmp 12505 self.pos = _save19 12506 12507 _save28 = self.pos 12508 while true # sequence 12509 _save29 = self.pos 12510 12511 _save30 = self.pos 12512 while true # sequence 12513 _tmp = apply(:_Sp) 12514 unless _tmp 12515 self.pos = _save30 12516 break 12517 end 12518 _tmp = apply(:_Ticks1) 12519 unless _tmp 12520 self.pos = _save30 12521 end 12522 break 12523 end # end sequence 12524 12525 _tmp = _tmp ? nil : true 12526 self.pos = _save29 12527 unless _tmp 12528 self.pos = _save28 12529 break 12530 end 12531 12532 _save31 = self.pos 12533 while true # choice 12534 _tmp = apply(:_Spacechar) 12535 break if _tmp 12536 self.pos = _save31 12537 12538 _save32 = self.pos 12539 while true # sequence 12540 _tmp = apply(:_Newline) 12541 unless _tmp 12542 self.pos = _save32 12543 break 12544 end 12545 _save33 = self.pos 12546 _tmp = apply(:_BlankLine) 12547 _tmp = _tmp ? nil : true 12548 self.pos = _save33 12549 unless _tmp 12550 self.pos = _save32 12551 end 12552 break 12553 end # end sequence 12554 12555 break if _tmp 12556 self.pos = _save31 12557 break 12558 end # end choice 12559 12560 unless _tmp 12561 self.pos = _save28 12562 end 12563 break 12564 end # end sequence 12565 12566 break if _tmp 12567 self.pos = _save19 12568 break 12569 end # end choice 12570 12571 break unless _tmp 12572 end 12573 _tmp = true 12574 else 12575 self.pos = _save3 12576 end 12577 if _tmp 12578 text = get_text(_text_start) 12579 end 12580 unless _tmp 12581 self.pos = _save2 12582 break 12583 end 12584 _tmp = apply(:_Sp) 12585 unless _tmp 12586 self.pos = _save2 12587 break 12588 end 12589 _tmp = apply(:_Ticks1) 12590 unless _tmp 12591 self.pos = _save2 12592 end 12593 break 12594 end # end sequence 12595 12596 break if _tmp 12597 self.pos = _save1 12598 12599 _save34 = self.pos 12600 while true # sequence 12601 _tmp = apply(:_Ticks2) 12602 unless _tmp 12603 self.pos = _save34 12604 break 12605 end 12606 _tmp = apply(:_Sp) 12607 unless _tmp 12608 self.pos = _save34 12609 break 12610 end 12611 _text_start = self.pos 12612 _save35 = self.pos 12613 12614 _save36 = self.pos 12615 while true # choice 12616 _save37 = self.pos 12617 12618 _save38 = self.pos 12619 while true # sequence 12620 _save39 = self.pos 12621 _tmp = match_string("`") 12622 _tmp = _tmp ? nil : true 12623 self.pos = _save39 12624 unless _tmp 12625 self.pos = _save38 12626 break 12627 end 12628 _tmp = apply(:_Nonspacechar) 12629 unless _tmp 12630 self.pos = _save38 12631 end 12632 break 12633 end # end sequence 12634 12635 if _tmp 12636 while true 12637 12638 _save40 = self.pos 12639 while true # sequence 12640 _save41 = self.pos 12641 _tmp = match_string("`") 12642 _tmp = _tmp ? nil : true 12643 self.pos = _save41 12644 unless _tmp 12645 self.pos = _save40 12646 break 12647 end 12648 _tmp = apply(:_Nonspacechar) 12649 unless _tmp 12650 self.pos = _save40 12651 end 12652 break 12653 end # end sequence 12654 12655 break unless _tmp 12656 end 12657 _tmp = true 12658 else 12659 self.pos = _save37 12660 end 12661 break if _tmp 12662 self.pos = _save36 12663 12664 _save42 = self.pos 12665 while true # sequence 12666 _save43 = self.pos 12667 _tmp = apply(:_Ticks2) 12668 _tmp = _tmp ? nil : true 12669 self.pos = _save43 12670 unless _tmp 12671 self.pos = _save42 12672 break 12673 end 12674 _save44 = self.pos 12675 _tmp = match_string("`") 12676 if _tmp 12677 while true 12678 _tmp = match_string("`") 12679 break unless _tmp 12680 end 12681 _tmp = true 12682 else 12683 self.pos = _save44 12684 end 12685 unless _tmp 12686 self.pos = _save42 12687 end 12688 break 12689 end # end sequence 12690 12691 break if _tmp 12692 self.pos = _save36 12693 12694 _save45 = self.pos 12695 while true # sequence 12696 _save46 = self.pos 12697 12698 _save47 = self.pos 12699 while true # sequence 12700 _tmp = apply(:_Sp) 12701 unless _tmp 12702 self.pos = _save47 12703 break 12704 end 12705 _tmp = apply(:_Ticks2) 12706 unless _tmp 12707 self.pos = _save47 12708 end 12709 break 12710 end # end sequence 12711 12712 _tmp = _tmp ? nil : true 12713 self.pos = _save46 12714 unless _tmp 12715 self.pos = _save45 12716 break 12717 end 12718 12719 _save48 = self.pos 12720 while true # choice 12721 _tmp = apply(:_Spacechar) 12722 break if _tmp 12723 self.pos = _save48 12724 12725 _save49 = self.pos 12726 while true # sequence 12727 _tmp = apply(:_Newline) 12728 unless _tmp 12729 self.pos = _save49 12730 break 12731 end 12732 _save50 = self.pos 12733 _tmp = apply(:_BlankLine) 12734 _tmp = _tmp ? nil : true 12735 self.pos = _save50 12736 unless _tmp 12737 self.pos = _save49 12738 end 12739 break 12740 end # end sequence 12741 12742 break if _tmp 12743 self.pos = _save48 12744 break 12745 end # end choice 12746 12747 unless _tmp 12748 self.pos = _save45 12749 end 12750 break 12751 end # end sequence 12752 12753 break if _tmp 12754 self.pos = _save36 12755 break 12756 end # end choice 12757 12758 if _tmp 12759 while true 12760 12761 _save51 = self.pos 12762 while true # choice 12763 _save52 = self.pos 12764 12765 _save53 = self.pos 12766 while true # sequence 12767 _save54 = self.pos 12768 _tmp = match_string("`") 12769 _tmp = _tmp ? nil : true 12770 self.pos = _save54 12771 unless _tmp 12772 self.pos = _save53 12773 break 12774 end 12775 _tmp = apply(:_Nonspacechar) 12776 unless _tmp 12777 self.pos = _save53 12778 end 12779 break 12780 end # end sequence 12781 12782 if _tmp 12783 while true 12784 12785 _save55 = self.pos 12786 while true # sequence 12787 _save56 = self.pos 12788 _tmp = match_string("`") 12789 _tmp = _tmp ? nil : true 12790 self.pos = _save56 12791 unless _tmp 12792 self.pos = _save55 12793 break 12794 end 12795 _tmp = apply(:_Nonspacechar) 12796 unless _tmp 12797 self.pos = _save55 12798 end 12799 break 12800 end # end sequence 12801 12802 break unless _tmp 12803 end 12804 _tmp = true 12805 else 12806 self.pos = _save52 12807 end 12808 break if _tmp 12809 self.pos = _save51 12810 12811 _save57 = self.pos 12812 while true # sequence 12813 _save58 = self.pos 12814 _tmp = apply(:_Ticks2) 12815 _tmp = _tmp ? nil : true 12816 self.pos = _save58 12817 unless _tmp 12818 self.pos = _save57 12819 break 12820 end 12821 _save59 = self.pos 12822 _tmp = match_string("`") 12823 if _tmp 12824 while true 12825 _tmp = match_string("`") 12826 break unless _tmp 12827 end 12828 _tmp = true 12829 else 12830 self.pos = _save59 12831 end 12832 unless _tmp 12833 self.pos = _save57 12834 end 12835 break 12836 end # end sequence 12837 12838 break if _tmp 12839 self.pos = _save51 12840 12841 _save60 = self.pos 12842 while true # sequence 12843 _save61 = self.pos 12844 12845 _save62 = self.pos 12846 while true # sequence 12847 _tmp = apply(:_Sp) 12848 unless _tmp 12849 self.pos = _save62 12850 break 12851 end 12852 _tmp = apply(:_Ticks2) 12853 unless _tmp 12854 self.pos = _save62 12855 end 12856 break 12857 end # end sequence 12858 12859 _tmp = _tmp ? nil : true 12860 self.pos = _save61 12861 unless _tmp 12862 self.pos = _save60 12863 break 12864 end 12865 12866 _save63 = self.pos 12867 while true # choice 12868 _tmp = apply(:_Spacechar) 12869 break if _tmp 12870 self.pos = _save63 12871 12872 _save64 = self.pos 12873 while true # sequence 12874 _tmp = apply(:_Newline) 12875 unless _tmp 12876 self.pos = _save64 12877 break 12878 end 12879 _save65 = self.pos 12880 _tmp = apply(:_BlankLine) 12881 _tmp = _tmp ? nil : true 12882 self.pos = _save65 12883 unless _tmp 12884 self.pos = _save64 12885 end 12886 break 12887 end # end sequence 12888 12889 break if _tmp 12890 self.pos = _save63 12891 break 12892 end # end choice 12893 12894 unless _tmp 12895 self.pos = _save60 12896 end 12897 break 12898 end # end sequence 12899 12900 break if _tmp 12901 self.pos = _save51 12902 break 12903 end # end choice 12904 12905 break unless _tmp 12906 end 12907 _tmp = true 12908 else 12909 self.pos = _save35 12910 end 12911 if _tmp 12912 text = get_text(_text_start) 12913 end 12914 unless _tmp 12915 self.pos = _save34 12916 break 12917 end 12918 _tmp = apply(:_Sp) 12919 unless _tmp 12920 self.pos = _save34 12921 break 12922 end 12923 _tmp = apply(:_Ticks2) 12924 unless _tmp 12925 self.pos = _save34 12926 end 12927 break 12928 end # end sequence 12929 12930 break if _tmp 12931 self.pos = _save1 12932 12933 _save66 = self.pos 12934 while true # sequence 12935 _tmp = apply(:_Ticks3) 12936 unless _tmp 12937 self.pos = _save66 12938 break 12939 end 12940 _tmp = apply(:_Sp) 12941 unless _tmp 12942 self.pos = _save66 12943 break 12944 end 12945 _text_start = self.pos 12946 _save67 = self.pos 12947 12948 _save68 = self.pos 12949 while true # choice 12950 _save69 = self.pos 12951 12952 _save70 = self.pos 12953 while true # sequence 12954 _save71 = self.pos 12955 _tmp = match_string("`") 12956 _tmp = _tmp ? nil : true 12957 self.pos = _save71 12958 unless _tmp 12959 self.pos = _save70 12960 break 12961 end 12962 _tmp = apply(:_Nonspacechar) 12963 unless _tmp 12964 self.pos = _save70 12965 end 12966 break 12967 end # end sequence 12968 12969 if _tmp 12970 while true 12971 12972 _save72 = self.pos 12973 while true # sequence 12974 _save73 = self.pos 12975 _tmp = match_string("`") 12976 _tmp = _tmp ? nil : true 12977 self.pos = _save73 12978 unless _tmp 12979 self.pos = _save72 12980 break 12981 end 12982 _tmp = apply(:_Nonspacechar) 12983 unless _tmp 12984 self.pos = _save72 12985 end 12986 break 12987 end # end sequence 12988 12989 break unless _tmp 12990 end 12991 _tmp = true 12992 else 12993 self.pos = _save69 12994 end 12995 break if _tmp 12996 self.pos = _save68 12997 12998 _save74 = self.pos 12999 while true # sequence 13000 _save75 = self.pos 13001 _tmp = apply(:_Ticks3) 13002 _tmp = _tmp ? nil : true 13003 self.pos = _save75 13004 unless _tmp 13005 self.pos = _save74 13006 break 13007 end 13008 _save76 = self.pos 13009 _tmp = match_string("`") 13010 if _tmp 13011 while true 13012 _tmp = match_string("`") 13013 break unless _tmp 13014 end 13015 _tmp = true 13016 else 13017 self.pos = _save76 13018 end 13019 unless _tmp 13020 self.pos = _save74 13021 end 13022 break 13023 end # end sequence 13024 13025 break if _tmp 13026 self.pos = _save68 13027 13028 _save77 = self.pos 13029 while true # sequence 13030 _save78 = self.pos 13031 13032 _save79 = self.pos 13033 while true # sequence 13034 _tmp = apply(:_Sp) 13035 unless _tmp 13036 self.pos = _save79 13037 break 13038 end 13039 _tmp = apply(:_Ticks3) 13040 unless _tmp 13041 self.pos = _save79 13042 end 13043 break 13044 end # end sequence 13045 13046 _tmp = _tmp ? nil : true 13047 self.pos = _save78 13048 unless _tmp 13049 self.pos = _save77 13050 break 13051 end 13052 13053 _save80 = self.pos 13054 while true # choice 13055 _tmp = apply(:_Spacechar) 13056 break if _tmp 13057 self.pos = _save80 13058 13059 _save81 = self.pos 13060 while true # sequence 13061 _tmp = apply(:_Newline) 13062 unless _tmp 13063 self.pos = _save81 13064 break 13065 end 13066 _save82 = self.pos 13067 _tmp = apply(:_BlankLine) 13068 _tmp = _tmp ? nil : true 13069 self.pos = _save82 13070 unless _tmp 13071 self.pos = _save81 13072 end 13073 break 13074 end # end sequence 13075 13076 break if _tmp 13077 self.pos = _save80 13078 break 13079 end # end choice 13080 13081 unless _tmp 13082 self.pos = _save77 13083 end 13084 break 13085 end # end sequence 13086 13087 break if _tmp 13088 self.pos = _save68 13089 break 13090 end # end choice 13091 13092 if _tmp 13093 while true 13094 13095 _save83 = self.pos 13096 while true # choice 13097 _save84 = self.pos 13098 13099 _save85 = self.pos 13100 while true # sequence 13101 _save86 = self.pos 13102 _tmp = match_string("`") 13103 _tmp = _tmp ? nil : true 13104 self.pos = _save86 13105 unless _tmp 13106 self.pos = _save85 13107 break 13108 end 13109 _tmp = apply(:_Nonspacechar) 13110 unless _tmp 13111 self.pos = _save85 13112 end 13113 break 13114 end # end sequence 13115 13116 if _tmp 13117 while true 13118 13119 _save87 = self.pos 13120 while true # sequence 13121 _save88 = self.pos 13122 _tmp = match_string("`") 13123 _tmp = _tmp ? nil : true 13124 self.pos = _save88 13125 unless _tmp 13126 self.pos = _save87 13127 break 13128 end 13129 _tmp = apply(:_Nonspacechar) 13130 unless _tmp 13131 self.pos = _save87 13132 end 13133 break 13134 end # end sequence 13135 13136 break unless _tmp 13137 end 13138 _tmp = true 13139 else 13140 self.pos = _save84 13141 end 13142 break if _tmp 13143 self.pos = _save83 13144 13145 _save89 = self.pos 13146 while true # sequence 13147 _save90 = self.pos 13148 _tmp = apply(:_Ticks3) 13149 _tmp = _tmp ? nil : true 13150 self.pos = _save90 13151 unless _tmp 13152 self.pos = _save89 13153 break 13154 end 13155 _save91 = self.pos 13156 _tmp = match_string("`") 13157 if _tmp 13158 while true 13159 _tmp = match_string("`") 13160 break unless _tmp 13161 end 13162 _tmp = true 13163 else 13164 self.pos = _save91 13165 end 13166 unless _tmp 13167 self.pos = _save89 13168 end 13169 break 13170 end # end sequence 13171 13172 break if _tmp 13173 self.pos = _save83 13174 13175 _save92 = self.pos 13176 while true # sequence 13177 _save93 = self.pos 13178 13179 _save94 = self.pos 13180 while true # sequence 13181 _tmp = apply(:_Sp) 13182 unless _tmp 13183 self.pos = _save94 13184 break 13185 end 13186 _tmp = apply(:_Ticks3) 13187 unless _tmp 13188 self.pos = _save94 13189 end 13190 break 13191 end # end sequence 13192 13193 _tmp = _tmp ? nil : true 13194 self.pos = _save93 13195 unless _tmp 13196 self.pos = _save92 13197 break 13198 end 13199 13200 _save95 = self.pos 13201 while true # choice 13202 _tmp = apply(:_Spacechar) 13203 break if _tmp 13204 self.pos = _save95 13205 13206 _save96 = self.pos 13207 while true # sequence 13208 _tmp = apply(:_Newline) 13209 unless _tmp 13210 self.pos = _save96 13211 break 13212 end 13213 _save97 = self.pos 13214 _tmp = apply(:_BlankLine) 13215 _tmp = _tmp ? nil : true 13216 self.pos = _save97 13217 unless _tmp 13218 self.pos = _save96 13219 end 13220 break 13221 end # end sequence 13222 13223 break if _tmp 13224 self.pos = _save95 13225 break 13226 end # end choice 13227 13228 unless _tmp 13229 self.pos = _save92 13230 end 13231 break 13232 end # end sequence 13233 13234 break if _tmp 13235 self.pos = _save83 13236 break 13237 end # end choice 13238 13239 break unless _tmp 13240 end 13241 _tmp = true 13242 else 13243 self.pos = _save67 13244 end 13245 if _tmp 13246 text = get_text(_text_start) 13247 end 13248 unless _tmp 13249 self.pos = _save66 13250 break 13251 end 13252 _tmp = apply(:_Sp) 13253 unless _tmp 13254 self.pos = _save66 13255 break 13256 end 13257 _tmp = apply(:_Ticks3) 13258 unless _tmp 13259 self.pos = _save66 13260 end 13261 break 13262 end # end sequence 13263 13264 break if _tmp 13265 self.pos = _save1 13266 13267 _save98 = self.pos 13268 while true # sequence 13269 _tmp = apply(:_Ticks4) 13270 unless _tmp 13271 self.pos = _save98 13272 break 13273 end 13274 _tmp = apply(:_Sp) 13275 unless _tmp 13276 self.pos = _save98 13277 break 13278 end 13279 _text_start = self.pos 13280 _save99 = self.pos 13281 13282 _save100 = self.pos 13283 while true # choice 13284 _save101 = self.pos 13285 13286 _save102 = self.pos 13287 while true # sequence 13288 _save103 = self.pos 13289 _tmp = match_string("`") 13290 _tmp = _tmp ? nil : true 13291 self.pos = _save103 13292 unless _tmp 13293 self.pos = _save102 13294 break 13295 end 13296 _tmp = apply(:_Nonspacechar) 13297 unless _tmp 13298 self.pos = _save102 13299 end 13300 break 13301 end # end sequence 13302 13303 if _tmp 13304 while true 13305 13306 _save104 = self.pos 13307 while true # sequence 13308 _save105 = self.pos 13309 _tmp = match_string("`") 13310 _tmp = _tmp ? nil : true 13311 self.pos = _save105 13312 unless _tmp 13313 self.pos = _save104 13314 break 13315 end 13316 _tmp = apply(:_Nonspacechar) 13317 unless _tmp 13318 self.pos = _save104 13319 end 13320 break 13321 end # end sequence 13322 13323 break unless _tmp 13324 end 13325 _tmp = true 13326 else 13327 self.pos = _save101 13328 end 13329 break if _tmp 13330 self.pos = _save100 13331 13332 _save106 = self.pos 13333 while true # sequence 13334 _save107 = self.pos 13335 _tmp = apply(:_Ticks4) 13336 _tmp = _tmp ? nil : true 13337 self.pos = _save107 13338 unless _tmp 13339 self.pos = _save106 13340 break 13341 end 13342 _save108 = self.pos 13343 _tmp = match_string("`") 13344 if _tmp 13345 while true 13346 _tmp = match_string("`") 13347 break unless _tmp 13348 end 13349 _tmp = true 13350 else 13351 self.pos = _save108 13352 end 13353 unless _tmp 13354 self.pos = _save106 13355 end 13356 break 13357 end # end sequence 13358 13359 break if _tmp 13360 self.pos = _save100 13361 13362 _save109 = self.pos 13363 while true # sequence 13364 _save110 = self.pos 13365 13366 _save111 = self.pos 13367 while true # sequence 13368 _tmp = apply(:_Sp) 13369 unless _tmp 13370 self.pos = _save111 13371 break 13372 end 13373 _tmp = apply(:_Ticks4) 13374 unless _tmp 13375 self.pos = _save111 13376 end 13377 break 13378 end # end sequence 13379 13380 _tmp = _tmp ? nil : true 13381 self.pos = _save110 13382 unless _tmp 13383 self.pos = _save109 13384 break 13385 end 13386 13387 _save112 = self.pos 13388 while true # choice 13389 _tmp = apply(:_Spacechar) 13390 break if _tmp 13391 self.pos = _save112 13392 13393 _save113 = self.pos 13394 while true # sequence 13395 _tmp = apply(:_Newline) 13396 unless _tmp 13397 self.pos = _save113 13398 break 13399 end 13400 _save114 = self.pos 13401 _tmp = apply(:_BlankLine) 13402 _tmp = _tmp ? nil : true 13403 self.pos = _save114 13404 unless _tmp 13405 self.pos = _save113 13406 end 13407 break 13408 end # end sequence 13409 13410 break if _tmp 13411 self.pos = _save112 13412 break 13413 end # end choice 13414 13415 unless _tmp 13416 self.pos = _save109 13417 end 13418 break 13419 end # end sequence 13420 13421 break if _tmp 13422 self.pos = _save100 13423 break 13424 end # end choice 13425 13426 if _tmp 13427 while true 13428 13429 _save115 = self.pos 13430 while true # choice 13431 _save116 = self.pos 13432 13433 _save117 = self.pos 13434 while true # sequence 13435 _save118 = self.pos 13436 _tmp = match_string("`") 13437 _tmp = _tmp ? nil : true 13438 self.pos = _save118 13439 unless _tmp 13440 self.pos = _save117 13441 break 13442 end 13443 _tmp = apply(:_Nonspacechar) 13444 unless _tmp 13445 self.pos = _save117 13446 end 13447 break 13448 end # end sequence 13449 13450 if _tmp 13451 while true 13452 13453 _save119 = self.pos 13454 while true # sequence 13455 _save120 = self.pos 13456 _tmp = match_string("`") 13457 _tmp = _tmp ? nil : true 13458 self.pos = _save120 13459 unless _tmp 13460 self.pos = _save119 13461 break 13462 end 13463 _tmp = apply(:_Nonspacechar) 13464 unless _tmp 13465 self.pos = _save119 13466 end 13467 break 13468 end # end sequence 13469 13470 break unless _tmp 13471 end 13472 _tmp = true 13473 else 13474 self.pos = _save116 13475 end 13476 break if _tmp 13477 self.pos = _save115 13478 13479 _save121 = self.pos 13480 while true # sequence 13481 _save122 = self.pos 13482 _tmp = apply(:_Ticks4) 13483 _tmp = _tmp ? nil : true 13484 self.pos = _save122 13485 unless _tmp 13486 self.pos = _save121 13487 break 13488 end 13489 _save123 = self.pos 13490 _tmp = match_string("`") 13491 if _tmp 13492 while true 13493 _tmp = match_string("`") 13494 break unless _tmp 13495 end 13496 _tmp = true 13497 else 13498 self.pos = _save123 13499 end 13500 unless _tmp 13501 self.pos = _save121 13502 end 13503 break 13504 end # end sequence 13505 13506 break if _tmp 13507 self.pos = _save115 13508 13509 _save124 = self.pos 13510 while true # sequence 13511 _save125 = self.pos 13512 13513 _save126 = self.pos 13514 while true # sequence 13515 _tmp = apply(:_Sp) 13516 unless _tmp 13517 self.pos = _save126 13518 break 13519 end 13520 _tmp = apply(:_Ticks4) 13521 unless _tmp 13522 self.pos = _save126 13523 end 13524 break 13525 end # end sequence 13526 13527 _tmp = _tmp ? nil : true 13528 self.pos = _save125 13529 unless _tmp 13530 self.pos = _save124 13531 break 13532 end 13533 13534 _save127 = self.pos 13535 while true # choice 13536 _tmp = apply(:_Spacechar) 13537 break if _tmp 13538 self.pos = _save127 13539 13540 _save128 = self.pos 13541 while true # sequence 13542 _tmp = apply(:_Newline) 13543 unless _tmp 13544 self.pos = _save128 13545 break 13546 end 13547 _save129 = self.pos 13548 _tmp = apply(:_BlankLine) 13549 _tmp = _tmp ? nil : true 13550 self.pos = _save129 13551 unless _tmp 13552 self.pos = _save128 13553 end 13554 break 13555 end # end sequence 13556 13557 break if _tmp 13558 self.pos = _save127 13559 break 13560 end # end choice 13561 13562 unless _tmp 13563 self.pos = _save124 13564 end 13565 break 13566 end # end sequence 13567 13568 break if _tmp 13569 self.pos = _save115 13570 break 13571 end # end choice 13572 13573 break unless _tmp 13574 end 13575 _tmp = true 13576 else 13577 self.pos = _save99 13578 end 13579 if _tmp 13580 text = get_text(_text_start) 13581 end 13582 unless _tmp 13583 self.pos = _save98 13584 break 13585 end 13586 _tmp = apply(:_Sp) 13587 unless _tmp 13588 self.pos = _save98 13589 break 13590 end 13591 _tmp = apply(:_Ticks4) 13592 unless _tmp 13593 self.pos = _save98 13594 end 13595 break 13596 end # end sequence 13597 13598 break if _tmp 13599 self.pos = _save1 13600 13601 _save130 = self.pos 13602 while true # sequence 13603 _tmp = apply(:_Ticks5) 13604 unless _tmp 13605 self.pos = _save130 13606 break 13607 end 13608 _tmp = apply(:_Sp) 13609 unless _tmp 13610 self.pos = _save130 13611 break 13612 end 13613 _text_start = self.pos 13614 _save131 = self.pos 13615 13616 _save132 = self.pos 13617 while true # choice 13618 _save133 = self.pos 13619 13620 _save134 = self.pos 13621 while true # sequence 13622 _save135 = self.pos 13623 _tmp = match_string("`") 13624 _tmp = _tmp ? nil : true 13625 self.pos = _save135 13626 unless _tmp 13627 self.pos = _save134 13628 break 13629 end 13630 _tmp = apply(:_Nonspacechar) 13631 unless _tmp 13632 self.pos = _save134 13633 end 13634 break 13635 end # end sequence 13636 13637 if _tmp 13638 while true 13639 13640 _save136 = self.pos 13641 while true # sequence 13642 _save137 = self.pos 13643 _tmp = match_string("`") 13644 _tmp = _tmp ? nil : true 13645 self.pos = _save137 13646 unless _tmp 13647 self.pos = _save136 13648 break 13649 end 13650 _tmp = apply(:_Nonspacechar) 13651 unless _tmp 13652 self.pos = _save136 13653 end 13654 break 13655 end # end sequence 13656 13657 break unless _tmp 13658 end 13659 _tmp = true 13660 else 13661 self.pos = _save133 13662 end 13663 break if _tmp 13664 self.pos = _save132 13665 13666 _save138 = self.pos 13667 while true # sequence 13668 _save139 = self.pos 13669 _tmp = apply(:_Ticks5) 13670 _tmp = _tmp ? nil : true 13671 self.pos = _save139 13672 unless _tmp 13673 self.pos = _save138 13674 break 13675 end 13676 _save140 = self.pos 13677 _tmp = match_string("`") 13678 if _tmp 13679 while true 13680 _tmp = match_string("`") 13681 break unless _tmp 13682 end 13683 _tmp = true 13684 else 13685 self.pos = _save140 13686 end 13687 unless _tmp 13688 self.pos = _save138 13689 end 13690 break 13691 end # end sequence 13692 13693 break if _tmp 13694 self.pos = _save132 13695 13696 _save141 = self.pos 13697 while true # sequence 13698 _save142 = self.pos 13699 13700 _save143 = self.pos 13701 while true # sequence 13702 _tmp = apply(:_Sp) 13703 unless _tmp 13704 self.pos = _save143 13705 break 13706 end 13707 _tmp = apply(:_Ticks5) 13708 unless _tmp 13709 self.pos = _save143 13710 end 13711 break 13712 end # end sequence 13713 13714 _tmp = _tmp ? nil : true 13715 self.pos = _save142 13716 unless _tmp 13717 self.pos = _save141 13718 break 13719 end 13720 13721 _save144 = self.pos 13722 while true # choice 13723 _tmp = apply(:_Spacechar) 13724 break if _tmp 13725 self.pos = _save144 13726 13727 _save145 = self.pos 13728 while true # sequence 13729 _tmp = apply(:_Newline) 13730 unless _tmp 13731 self.pos = _save145 13732 break 13733 end 13734 _save146 = self.pos 13735 _tmp = apply(:_BlankLine) 13736 _tmp = _tmp ? nil : true 13737 self.pos = _save146 13738 unless _tmp 13739 self.pos = _save145 13740 end 13741 break 13742 end # end sequence 13743 13744 break if _tmp 13745 self.pos = _save144 13746 break 13747 end # end choice 13748 13749 unless _tmp 13750 self.pos = _save141 13751 end 13752 break 13753 end # end sequence 13754 13755 break if _tmp 13756 self.pos = _save132 13757 break 13758 end # end choice 13759 13760 if _tmp 13761 while true 13762 13763 _save147 = self.pos 13764 while true # choice 13765 _save148 = self.pos 13766 13767 _save149 = self.pos 13768 while true # sequence 13769 _save150 = self.pos 13770 _tmp = match_string("`") 13771 _tmp = _tmp ? nil : true 13772 self.pos = _save150 13773 unless _tmp 13774 self.pos = _save149 13775 break 13776 end 13777 _tmp = apply(:_Nonspacechar) 13778 unless _tmp 13779 self.pos = _save149 13780 end 13781 break 13782 end # end sequence 13783 13784 if _tmp 13785 while true 13786 13787 _save151 = self.pos 13788 while true # sequence 13789 _save152 = self.pos 13790 _tmp = match_string("`") 13791 _tmp = _tmp ? nil : true 13792 self.pos = _save152 13793 unless _tmp 13794 self.pos = _save151 13795 break 13796 end 13797 _tmp = apply(:_Nonspacechar) 13798 unless _tmp 13799 self.pos = _save151 13800 end 13801 break 13802 end # end sequence 13803 13804 break unless _tmp 13805 end 13806 _tmp = true 13807 else 13808 self.pos = _save148 13809 end 13810 break if _tmp 13811 self.pos = _save147 13812 13813 _save153 = self.pos 13814 while true # sequence 13815 _save154 = self.pos 13816 _tmp = apply(:_Ticks5) 13817 _tmp = _tmp ? nil : true 13818 self.pos = _save154 13819 unless _tmp 13820 self.pos = _save153 13821 break 13822 end 13823 _save155 = self.pos 13824 _tmp = match_string("`") 13825 if _tmp 13826 while true 13827 _tmp = match_string("`") 13828 break unless _tmp 13829 end 13830 _tmp = true 13831 else 13832 self.pos = _save155 13833 end 13834 unless _tmp 13835 self.pos = _save153 13836 end 13837 break 13838 end # end sequence 13839 13840 break if _tmp 13841 self.pos = _save147 13842 13843 _save156 = self.pos 13844 while true # sequence 13845 _save157 = self.pos 13846 13847 _save158 = self.pos 13848 while true # sequence 13849 _tmp = apply(:_Sp) 13850 unless _tmp 13851 self.pos = _save158 13852 break 13853 end 13854 _tmp = apply(:_Ticks5) 13855 unless _tmp 13856 self.pos = _save158 13857 end 13858 break 13859 end # end sequence 13860 13861 _tmp = _tmp ? nil : true 13862 self.pos = _save157 13863 unless _tmp 13864 self.pos = _save156 13865 break 13866 end 13867 13868 _save159 = self.pos 13869 while true # choice 13870 _tmp = apply(:_Spacechar) 13871 break if _tmp 13872 self.pos = _save159 13873 13874 _save160 = self.pos 13875 while true # sequence 13876 _tmp = apply(:_Newline) 13877 unless _tmp 13878 self.pos = _save160 13879 break 13880 end 13881 _save161 = self.pos 13882 _tmp = apply(:_BlankLine) 13883 _tmp = _tmp ? nil : true 13884 self.pos = _save161 13885 unless _tmp 13886 self.pos = _save160 13887 end 13888 break 13889 end # end sequence 13890 13891 break if _tmp 13892 self.pos = _save159 13893 break 13894 end # end choice 13895 13896 unless _tmp 13897 self.pos = _save156 13898 end 13899 break 13900 end # end sequence 13901 13902 break if _tmp 13903 self.pos = _save147 13904 break 13905 end # end choice 13906 13907 break unless _tmp 13908 end 13909 _tmp = true 13910 else 13911 self.pos = _save131 13912 end 13913 if _tmp 13914 text = get_text(_text_start) 13915 end 13916 unless _tmp 13917 self.pos = _save130 13918 break 13919 end 13920 _tmp = apply(:_Sp) 13921 unless _tmp 13922 self.pos = _save130 13923 break 13924 end 13925 _tmp = apply(:_Ticks5) 13926 unless _tmp 13927 self.pos = _save130 13928 end 13929 break 13930 end # end sequence 13931 13932 break if _tmp 13933 self.pos = _save1 13934 break 13935 end # end choice 13936 13937 unless _tmp 13938 self.pos = _save 13939 break 13940 end 13941 @result = begin; "<code>#{text}</code>" ; end 13942 _tmp = true 13943 unless _tmp 13944 self.pos = _save 13945 end 13946 break 13947 end # end sequence 13948 13949 set_failed_rule :_Code unless _tmp 13950 return _tmp 13951 end 13952 13953 # RawHtml = < (HtmlComment | HtmlBlockScript | HtmlTag) > { if html? then text else '' end } 13954 def _RawHtml 13955 13956 _save = self.pos 13957 while true # sequence 13958 _text_start = self.pos 13959 13960 _save1 = self.pos 13961 while true # choice 13962 _tmp = apply(:_HtmlComment) 13963 break if _tmp 13964 self.pos = _save1 13965 _tmp = apply(:_HtmlBlockScript) 13966 break if _tmp 13967 self.pos = _save1 13968 _tmp = apply(:_HtmlTag) 13969 break if _tmp 13970 self.pos = _save1 13971 break 13972 end # end choice 13973 13974 if _tmp 13975 text = get_text(_text_start) 13976 end 13977 unless _tmp 13978 self.pos = _save 13979 break 13980 end 13981 @result = begin; if html? then text else '' end ; end 13982 _tmp = true 13983 unless _tmp 13984 self.pos = _save 13985 end 13986 break 13987 end # end sequence 13988 13989 set_failed_rule :_RawHtml unless _tmp 13990 return _tmp 13991 end 13992 13993 # BlankLine = Sp Newline { "\n" } 13994 def _BlankLine 13995 13996 _save = self.pos 13997 while true # sequence 13998 _tmp = apply(:_Sp) 13999 unless _tmp 14000 self.pos = _save 14001 break 14002 end 14003 _tmp = apply(:_Newline) 14004 unless _tmp 14005 self.pos = _save 14006 break 14007 end 14008 @result = begin; "\n" ; end 14009 _tmp = true 14010 unless _tmp 14011 self.pos = _save 14012 end 14013 break 14014 end # end sequence 14015 14016 set_failed_rule :_BlankLine unless _tmp 14017 return _tmp 14018 end 14019 14020 # Quoted = ("\"" (!"\"" .)* "\"" | "'" (!"'" .)* "'") 14021 def _Quoted 14022 14023 _save = self.pos 14024 while true # choice 14025 14026 _save1 = self.pos 14027 while true # sequence 14028 _tmp = match_string("\"") 14029 unless _tmp 14030 self.pos = _save1 14031 break 14032 end 14033 while true 14034 14035 _save3 = self.pos 14036 while true # sequence 14037 _save4 = self.pos 14038 _tmp = match_string("\"") 14039 _tmp = _tmp ? nil : true 14040 self.pos = _save4 14041 unless _tmp 14042 self.pos = _save3 14043 break 14044 end 14045 _tmp = get_byte 14046 unless _tmp 14047 self.pos = _save3 14048 end 14049 break 14050 end # end sequence 14051 14052 break unless _tmp 14053 end 14054 _tmp = true 14055 unless _tmp 14056 self.pos = _save1 14057 break 14058 end 14059 _tmp = match_string("\"") 14060 unless _tmp 14061 self.pos = _save1 14062 end 14063 break 14064 end # end sequence 14065 14066 break if _tmp 14067 self.pos = _save 14068 14069 _save5 = self.pos 14070 while true # sequence 14071 _tmp = match_string("'") 14072 unless _tmp 14073 self.pos = _save5 14074 break 14075 end 14076 while true 14077 14078 _save7 = self.pos 14079 while true # sequence 14080 _save8 = self.pos 14081 _tmp = match_string("'") 14082 _tmp = _tmp ? nil : true 14083 self.pos = _save8 14084 unless _tmp 14085 self.pos = _save7 14086 break 14087 end 14088 _tmp = get_byte 14089 unless _tmp 14090 self.pos = _save7 14091 end 14092 break 14093 end # end sequence 14094 14095 break unless _tmp 14096 end 14097 _tmp = true 14098 unless _tmp 14099 self.pos = _save5 14100 break 14101 end 14102 _tmp = match_string("'") 14103 unless _tmp 14104 self.pos = _save5 14105 end 14106 break 14107 end # end sequence 14108 14109 break if _tmp 14110 self.pos = _save 14111 break 14112 end # end choice 14113 14114 set_failed_rule :_Quoted unless _tmp 14115 return _tmp 14116 end 14117 14118 # HtmlAttribute = (AlphanumericAscii | "-")+ Spnl ("=" Spnl (Quoted | (!">" Nonspacechar)+))? Spnl 14119 def _HtmlAttribute 14120 14121 _save = self.pos 14122 while true # sequence 14123 _save1 = self.pos 14124 14125 _save2 = self.pos 14126 while true # choice 14127 _tmp = apply(:_AlphanumericAscii) 14128 break if _tmp 14129 self.pos = _save2 14130 _tmp = match_string("-") 14131 break if _tmp 14132 self.pos = _save2 14133 break 14134 end # end choice 14135 14136 if _tmp 14137 while true 14138 14139 _save3 = self.pos 14140 while true # choice 14141 _tmp = apply(:_AlphanumericAscii) 14142 break if _tmp 14143 self.pos = _save3 14144 _tmp = match_string("-") 14145 break if _tmp 14146 self.pos = _save3 14147 break 14148 end # end choice 14149 14150 break unless _tmp 14151 end 14152 _tmp = true 14153 else 14154 self.pos = _save1 14155 end 14156 unless _tmp 14157 self.pos = _save 14158 break 14159 end 14160 _tmp = apply(:_Spnl) 14161 unless _tmp 14162 self.pos = _save 14163 break 14164 end 14165 _save4 = self.pos 14166 14167 _save5 = self.pos 14168 while true # sequence 14169 _tmp = match_string("=") 14170 unless _tmp 14171 self.pos = _save5 14172 break 14173 end 14174 _tmp = apply(:_Spnl) 14175 unless _tmp 14176 self.pos = _save5 14177 break 14178 end 14179 14180 _save6 = self.pos 14181 while true # choice 14182 _tmp = apply(:_Quoted) 14183 break if _tmp 14184 self.pos = _save6 14185 _save7 = self.pos 14186 14187 _save8 = self.pos 14188 while true # sequence 14189 _save9 = self.pos 14190 _tmp = match_string(">") 14191 _tmp = _tmp ? nil : true 14192 self.pos = _save9 14193 unless _tmp 14194 self.pos = _save8 14195 break 14196 end 14197 _tmp = apply(:_Nonspacechar) 14198 unless _tmp 14199 self.pos = _save8 14200 end 14201 break 14202 end # end sequence 14203 14204 if _tmp 14205 while true 14206 14207 _save10 = self.pos 14208 while true # sequence 14209 _save11 = self.pos 14210 _tmp = match_string(">") 14211 _tmp = _tmp ? nil : true 14212 self.pos = _save11 14213 unless _tmp 14214 self.pos = _save10 14215 break 14216 end 14217 _tmp = apply(:_Nonspacechar) 14218 unless _tmp 14219 self.pos = _save10 14220 end 14221 break 14222 end # end sequence 14223 14224 break unless _tmp 14225 end 14226 _tmp = true 14227 else 14228 self.pos = _save7 14229 end 14230 break if _tmp 14231 self.pos = _save6 14232 break 14233 end # end choice 14234 14235 unless _tmp 14236 self.pos = _save5 14237 end 14238 break 14239 end # end sequence 14240 14241 unless _tmp 14242 _tmp = true 14243 self.pos = _save4 14244 end 14245 unless _tmp 14246 self.pos = _save 14247 break 14248 end 14249 _tmp = apply(:_Spnl) 14250 unless _tmp 14251 self.pos = _save 14252 end 14253 break 14254 end # end sequence 14255 14256 set_failed_rule :_HtmlAttribute unless _tmp 14257 return _tmp 14258 end 14259 14260 # HtmlComment = "<!--" (!"-->" .)* "-->" 14261 def _HtmlComment 14262 14263 _save = self.pos 14264 while true # sequence 14265 _tmp = match_string("<!--") 14266 unless _tmp 14267 self.pos = _save 14268 break 14269 end 14270 while true 14271 14272 _save2 = self.pos 14273 while true # sequence 14274 _save3 = self.pos 14275 _tmp = match_string("-->") 14276 _tmp = _tmp ? nil : true 14277 self.pos = _save3 14278 unless _tmp 14279 self.pos = _save2 14280 break 14281 end 14282 _tmp = get_byte 14283 unless _tmp 14284 self.pos = _save2 14285 end 14286 break 14287 end # end sequence 14288 14289 break unless _tmp 14290 end 14291 _tmp = true 14292 unless _tmp 14293 self.pos = _save 14294 break 14295 end 14296 _tmp = match_string("-->") 14297 unless _tmp 14298 self.pos = _save 14299 end 14300 break 14301 end # end sequence 14302 14303 set_failed_rule :_HtmlComment unless _tmp 14304 return _tmp 14305 end 14306 14307 # HtmlTag = "<" Spnl "/"? AlphanumericAscii+ Spnl HtmlAttribute* "/"? Spnl ">" 14308 def _HtmlTag 14309 14310 _save = self.pos 14311 while true # sequence 14312 _tmp = match_string("<") 14313 unless _tmp 14314 self.pos = _save 14315 break 14316 end 14317 _tmp = apply(:_Spnl) 14318 unless _tmp 14319 self.pos = _save 14320 break 14321 end 14322 _save1 = self.pos 14323 _tmp = match_string("/") 14324 unless _tmp 14325 _tmp = true 14326 self.pos = _save1 14327 end 14328 unless _tmp 14329 self.pos = _save 14330 break 14331 end 14332 _save2 = self.pos 14333 _tmp = apply(:_AlphanumericAscii) 14334 if _tmp 14335 while true 14336 _tmp = apply(:_AlphanumericAscii) 14337 break unless _tmp 14338 end 14339 _tmp = true 14340 else 14341 self.pos = _save2 14342 end 14343 unless _tmp 14344 self.pos = _save 14345 break 14346 end 14347 _tmp = apply(:_Spnl) 14348 unless _tmp 14349 self.pos = _save 14350 break 14351 end 14352 while true 14353 _tmp = apply(:_HtmlAttribute) 14354 break unless _tmp 14355 end 14356 _tmp = true 14357 unless _tmp 14358 self.pos = _save 14359 break 14360 end 14361 _save4 = self.pos 14362 _tmp = match_string("/") 14363 unless _tmp 14364 _tmp = true 14365 self.pos = _save4 14366 end 14367 unless _tmp 14368 self.pos = _save 14369 break 14370 end 14371 _tmp = apply(:_Spnl) 14372 unless _tmp 14373 self.pos = _save 14374 break 14375 end 14376 _tmp = match_string(">") 14377 unless _tmp 14378 self.pos = _save 14379 end 14380 break 14381 end # end sequence 14382 14383 set_failed_rule :_HtmlTag unless _tmp 14384 return _tmp 14385 end 14386 14387 # Eof = !. 14388 def _Eof 14389 _save = self.pos 14390 _tmp = get_byte 14391 _tmp = _tmp ? nil : true 14392 self.pos = _save 14393 set_failed_rule :_Eof unless _tmp 14394 return _tmp 14395 end 14396 14397 # Nonspacechar = !Spacechar !Newline . 14398 def _Nonspacechar 14399 14400 _save = self.pos 14401 while true # sequence 14402 _save1 = self.pos 14403 _tmp = apply(:_Spacechar) 14404 _tmp = _tmp ? nil : true 14405 self.pos = _save1 14406 unless _tmp 14407 self.pos = _save 14408 break 14409 end 14410 _save2 = self.pos 14411 _tmp = apply(:_Newline) 14412 _tmp = _tmp ? nil : true 14413 self.pos = _save2 14414 unless _tmp 14415 self.pos = _save 14416 break 14417 end 14418 _tmp = get_byte 14419 unless _tmp 14420 self.pos = _save 14421 end 14422 break 14423 end # end sequence 14424 14425 set_failed_rule :_Nonspacechar unless _tmp 14426 return _tmp 14427 end 14428 14429 # Sp = Spacechar* 14430 def _Sp 14431 while true 14432 _tmp = apply(:_Spacechar) 14433 break unless _tmp 14434 end 14435 _tmp = true 14436 set_failed_rule :_Sp unless _tmp 14437 return _tmp 14438 end 14439 14440 # Spnl = Sp (Newline Sp)? 14441 def _Spnl 14442 14443 _save = self.pos 14444 while true # sequence 14445 _tmp = apply(:_Sp) 14446 unless _tmp 14447 self.pos = _save 14448 break 14449 end 14450 _save1 = self.pos 14451 14452 _save2 = self.pos 14453 while true # sequence 14454 _tmp = apply(:_Newline) 14455 unless _tmp 14456 self.pos = _save2 14457 break 14458 end 14459 _tmp = apply(:_Sp) 14460 unless _tmp 14461 self.pos = _save2 14462 end 14463 break 14464 end # end sequence 14465 14466 unless _tmp 14467 _tmp = true 14468 self.pos = _save1 14469 end 14470 unless _tmp 14471 self.pos = _save 14472 end 14473 break 14474 end # end sequence 14475 14476 set_failed_rule :_Spnl unless _tmp 14477 return _tmp 14478 end 14479 14480 # SpecialChar = ("*" | "_" | "`" | "&" | "[" | "]" | "(" | ")" | "<" | "!" | "#" | "\\" | "'" | "\"" | ExtendedSpecialChar) 14481 def _SpecialChar 14482 14483 _save = self.pos 14484 while true # choice 14485 _tmp = match_string("*") 14486 break if _tmp 14487 self.pos = _save 14488 _tmp = match_string("_") 14489 break if _tmp 14490 self.pos = _save 14491 _tmp = match_string("`") 14492 break if _tmp 14493 self.pos = _save 14494 _tmp = match_string("&") 14495 break if _tmp 14496 self.pos = _save 14497 _tmp = match_string("[") 14498 break if _tmp 14499 self.pos = _save 14500 _tmp = match_string("]") 14501 break if _tmp 14502 self.pos = _save 14503 _tmp = match_string("(") 14504 break if _tmp 14505 self.pos = _save 14506 _tmp = match_string(")") 14507 break if _tmp 14508 self.pos = _save 14509 _tmp = match_string("<") 14510 break if _tmp 14511 self.pos = _save 14512 _tmp = match_string("!") 14513 break if _tmp 14514 self.pos = _save 14515 _tmp = match_string("#") 14516 break if _tmp 14517 self.pos = _save 14518 _tmp = match_string("\\") 14519 break if _tmp 14520 self.pos = _save 14521 _tmp = match_string("'") 14522 break if _tmp 14523 self.pos = _save 14524 _tmp = match_string("\"") 14525 break if _tmp 14526 self.pos = _save 14527 _tmp = apply(:_ExtendedSpecialChar) 14528 break if _tmp 14529 self.pos = _save 14530 break 14531 end # end choice 14532 14533 set_failed_rule :_SpecialChar unless _tmp 14534 return _tmp 14535 end 14536 14537 # NormalChar = !(SpecialChar | Spacechar | Newline) . 14538 def _NormalChar 14539 14540 _save = self.pos 14541 while true # sequence 14542 _save1 = self.pos 14543 14544 _save2 = self.pos 14545 while true # choice 14546 _tmp = apply(:_SpecialChar) 14547 break if _tmp 14548 self.pos = _save2 14549 _tmp = apply(:_Spacechar) 14550 break if _tmp 14551 self.pos = _save2 14552 _tmp = apply(:_Newline) 14553 break if _tmp 14554 self.pos = _save2 14555 break 14556 end # end choice 14557 14558 _tmp = _tmp ? nil : true 14559 self.pos = _save1 14560 unless _tmp 14561 self.pos = _save 14562 break 14563 end 14564 _tmp = get_byte 14565 unless _tmp 14566 self.pos = _save 14567 end 14568 break 14569 end # end sequence 14570 14571 set_failed_rule :_NormalChar unless _tmp 14572 return _tmp 14573 end 14574 14575 # Digit = [0-9] 14576 def _Digit 14577 _save = self.pos 14578 _tmp = get_byte 14579 if _tmp 14580 unless _tmp >= 48 and _tmp <= 57 14581 self.pos = _save 14582 _tmp = nil 14583 end 14584 end 14585 set_failed_rule :_Digit unless _tmp 14586 return _tmp 14587 end 14588 14589 # Alphanumeric = %literals.Alphanumeric 14590 def _Alphanumeric 14591 _tmp = @_grammar_literals.external_invoke(self, :_Alphanumeric) 14592 set_failed_rule :_Alphanumeric unless _tmp 14593 return _tmp 14594 end 14595 14596 # AlphanumericAscii = %literals.AlphanumericAscii 14597 def _AlphanumericAscii 14598 _tmp = @_grammar_literals.external_invoke(self, :_AlphanumericAscii) 14599 set_failed_rule :_AlphanumericAscii unless _tmp 14600 return _tmp 14601 end 14602 14603 # BOM = %literals.BOM 14604 def _BOM 14605 _tmp = @_grammar_literals.external_invoke(self, :_BOM) 14606 set_failed_rule :_BOM unless _tmp 14607 return _tmp 14608 end 14609 14610 # Newline = %literals.Newline 14611 def _Newline 14612 _tmp = @_grammar_literals.external_invoke(self, :_Newline) 14613 set_failed_rule :_Newline unless _tmp 14614 return _tmp 14615 end 14616 14617 # NonAlphanumeric = %literals.NonAlphanumeric 14618 def _NonAlphanumeric 14619 _tmp = @_grammar_literals.external_invoke(self, :_NonAlphanumeric) 14620 set_failed_rule :_NonAlphanumeric unless _tmp 14621 return _tmp 14622 end 14623 14624 # Spacechar = %literals.Spacechar 14625 def _Spacechar 14626 _tmp = @_grammar_literals.external_invoke(self, :_Spacechar) 14627 set_failed_rule :_Spacechar unless _tmp 14628 return _tmp 14629 end 14630 14631 # HexEntity = "&" "#" /[Xx]/ < /[0-9a-fA-F]+/ > ";" { [text.to_i(16)].pack 'U' } 14632 def _HexEntity 14633 14634 _save = self.pos 14635 while true # sequence 14636 _tmp = match_string("&") 14637 unless _tmp 14638 self.pos = _save 14639 break 14640 end 14641 _tmp = match_string("#") 14642 unless _tmp 14643 self.pos = _save 14644 break 14645 end 14646 _tmp = scan(/\A(?-mix:[Xx])/) 14647 unless _tmp 14648 self.pos = _save 14649 break 14650 end 14651 _text_start = self.pos 14652 _tmp = scan(/\A(?-mix:[0-9a-fA-F]+)/) 14653 if _tmp 14654 text = get_text(_text_start) 14655 end 14656 unless _tmp 14657 self.pos = _save 14658 break 14659 end 14660 _tmp = match_string(";") 14661 unless _tmp 14662 self.pos = _save 14663 break 14664 end 14665 @result = begin; [text.to_i(16)].pack 'U' ; end 14666 _tmp = true 14667 unless _tmp 14668 self.pos = _save 14669 end 14670 break 14671 end # end sequence 14672 14673 set_failed_rule :_HexEntity unless _tmp 14674 return _tmp 14675 end 14676 14677 # DecEntity = "&" "#" < /[0-9]+/ > ";" { [text.to_i].pack 'U' } 14678 def _DecEntity 14679 14680 _save = self.pos 14681 while true # sequence 14682 _tmp = match_string("&") 14683 unless _tmp 14684 self.pos = _save 14685 break 14686 end 14687 _tmp = match_string("#") 14688 unless _tmp 14689 self.pos = _save 14690 break 14691 end 14692 _text_start = self.pos 14693 _tmp = scan(/\A(?-mix:[0-9]+)/) 14694 if _tmp 14695 text = get_text(_text_start) 14696 end 14697 unless _tmp 14698 self.pos = _save 14699 break 14700 end 14701 _tmp = match_string(";") 14702 unless _tmp 14703 self.pos = _save 14704 break 14705 end 14706 @result = begin; [text.to_i].pack 'U' ; end 14707 _tmp = true 14708 unless _tmp 14709 self.pos = _save 14710 end 14711 break 14712 end # end sequence 14713 14714 set_failed_rule :_DecEntity unless _tmp 14715 return _tmp 14716 end 14717 14718 # CharEntity = "&" < /[A-Za-z0-9]+/ > ";" { if entity = HTML_ENTITIES[text] then entity.pack 'U*' else "&#{text};" end } 14719 def _CharEntity 14720 14721 _save = self.pos 14722 while true # sequence 14723 _tmp = match_string("&") 14724 unless _tmp 14725 self.pos = _save 14726 break 14727 end 14728 _text_start = self.pos 14729 _tmp = scan(/\A(?-mix:[A-Za-z0-9]+)/) 14730 if _tmp 14731 text = get_text(_text_start) 14732 end 14733 unless _tmp 14734 self.pos = _save 14735 break 14736 end 14737 _tmp = match_string(";") 14738 unless _tmp 14739 self.pos = _save 14740 break 14741 end 14742 @result = begin; if entity = HTML_ENTITIES[text] then 14743 entity.pack 'U*' 14744 else 14745 "&#{text};" 14746 end 14747 ; end 14748 _tmp = true 14749 unless _tmp 14750 self.pos = _save 14751 end 14752 break 14753 end # end sequence 14754 14755 set_failed_rule :_CharEntity unless _tmp 14756 return _tmp 14757 end 14758 14759 # NonindentSpace = (" " | " " | " " | "") 14760 def _NonindentSpace 14761 14762 _save = self.pos 14763 while true # choice 14764 _tmp = match_string(" ") 14765 break if _tmp 14766 self.pos = _save 14767 _tmp = match_string(" ") 14768 break if _tmp 14769 self.pos = _save 14770 _tmp = match_string(" ") 14771 break if _tmp 14772 self.pos = _save 14773 _tmp = match_string("") 14774 break if _tmp 14775 self.pos = _save 14776 break 14777 end # end choice 14778 14779 set_failed_rule :_NonindentSpace unless _tmp 14780 return _tmp 14781 end 14782 14783 # Indent = ("\t" | " ") 14784 def _Indent 14785 14786 _save = self.pos 14787 while true # choice 14788 _tmp = match_string("\t") 14789 break if _tmp 14790 self.pos = _save 14791 _tmp = match_string(" ") 14792 break if _tmp 14793 self.pos = _save 14794 break 14795 end # end choice 14796 14797 set_failed_rule :_Indent unless _tmp 14798 return _tmp 14799 end 14800 14801 # IndentedLine = Indent Line 14802 def _IndentedLine 14803 14804 _save = self.pos 14805 while true # sequence 14806 _tmp = apply(:_Indent) 14807 unless _tmp 14808 self.pos = _save 14809 break 14810 end 14811 _tmp = apply(:_Line) 14812 unless _tmp 14813 self.pos = _save 14814 end 14815 break 14816 end # end sequence 14817 14818 set_failed_rule :_IndentedLine unless _tmp 14819 return _tmp 14820 end 14821 14822 # OptionallyIndentedLine = Indent? Line 14823 def _OptionallyIndentedLine 14824 14825 _save = self.pos 14826 while true # sequence 14827 _save1 = self.pos 14828 _tmp = apply(:_Indent) 14829 unless _tmp 14830 _tmp = true 14831 self.pos = _save1 14832 end 14833 unless _tmp 14834 self.pos = _save 14835 break 14836 end 14837 _tmp = apply(:_Line) 14838 unless _tmp 14839 self.pos = _save 14840 end 14841 break 14842 end # end sequence 14843 14844 set_failed_rule :_OptionallyIndentedLine unless _tmp 14845 return _tmp 14846 end 14847 14848 # StartList = &. { [] } 14849 def _StartList 14850 14851 _save = self.pos 14852 while true # sequence 14853 _save1 = self.pos 14854 _tmp = get_byte 14855 self.pos = _save1 14856 unless _tmp 14857 self.pos = _save 14858 break 14859 end 14860 @result = begin; [] ; end 14861 _tmp = true 14862 unless _tmp 14863 self.pos = _save 14864 end 14865 break 14866 end # end sequence 14867 14868 set_failed_rule :_StartList unless _tmp 14869 return _tmp 14870 end 14871 14872 # Line = RawLine:a { a } 14873 def _Line 14874 14875 _save = self.pos 14876 while true # sequence 14877 _tmp = apply(:_RawLine) 14878 a = @result 14879 unless _tmp 14880 self.pos = _save 14881 break 14882 end 14883 @result = begin; a ; end 14884 _tmp = true 14885 unless _tmp 14886 self.pos = _save 14887 end 14888 break 14889 end # end sequence 14890 14891 set_failed_rule :_Line unless _tmp 14892 return _tmp 14893 end 14894 14895 # RawLine = (< (!"\r" !"\n" .)* Newline > | < .+ > Eof) { text } 14896 def _RawLine 14897 14898 _save = self.pos 14899 while true # sequence 14900 14901 _save1 = self.pos 14902 while true # choice 14903 _text_start = self.pos 14904 14905 _save2 = self.pos 14906 while true # sequence 14907 while true 14908 14909 _save4 = self.pos 14910 while true # sequence 14911 _save5 = self.pos 14912 _tmp = match_string("\r") 14913 _tmp = _tmp ? nil : true 14914 self.pos = _save5 14915 unless _tmp 14916 self.pos = _save4 14917 break 14918 end 14919 _save6 = self.pos 14920 _tmp = match_string("\n") 14921 _tmp = _tmp ? nil : true 14922 self.pos = _save6 14923 unless _tmp 14924 self.pos = _save4 14925 break 14926 end 14927 _tmp = get_byte 14928 unless _tmp 14929 self.pos = _save4 14930 end 14931 break 14932 end # end sequence 14933 14934 break unless _tmp 14935 end 14936 _tmp = true 14937 unless _tmp 14938 self.pos = _save2 14939 break 14940 end 14941 _tmp = apply(:_Newline) 14942 unless _tmp 14943 self.pos = _save2 14944 end 14945 break 14946 end # end sequence 14947 14948 if _tmp 14949 text = get_text(_text_start) 14950 end 14951 break if _tmp 14952 self.pos = _save1 14953 14954 _save7 = self.pos 14955 while true # sequence 14956 _text_start = self.pos 14957 _save8 = self.pos 14958 _tmp = get_byte 14959 if _tmp 14960 while true 14961 _tmp = get_byte 14962 break unless _tmp 14963 end 14964 _tmp = true 14965 else 14966 self.pos = _save8 14967 end 14968 if _tmp 14969 text = get_text(_text_start) 14970 end 14971 unless _tmp 14972 self.pos = _save7 14973 break 14974 end 14975 _tmp = apply(:_Eof) 14976 unless _tmp 14977 self.pos = _save7 14978 end 14979 break 14980 end # end sequence 14981 14982 break if _tmp 14983 self.pos = _save1 14984 break 14985 end # end choice 14986 14987 unless _tmp 14988 self.pos = _save 14989 break 14990 end 14991 @result = begin; text ; end 14992 _tmp = true 14993 unless _tmp 14994 self.pos = _save 14995 end 14996 break 14997 end # end sequence 14998 14999 set_failed_rule :_RawLine unless _tmp 15000 return _tmp 15001 end 15002 15003 # SkipBlock = (HtmlBlock | (!"#" !SetextBottom1 !SetextBottom2 !BlankLine RawLine)+ BlankLine* | BlankLine+ | RawLine) 15004 def _SkipBlock 15005 15006 _save = self.pos 15007 while true # choice 15008 _tmp = apply(:_HtmlBlock) 15009 break if _tmp 15010 self.pos = _save 15011 15012 _save1 = self.pos 15013 while true # sequence 15014 _save2 = self.pos 15015 15016 _save3 = self.pos 15017 while true # sequence 15018 _save4 = self.pos 15019 _tmp = match_string("#") 15020 _tmp = _tmp ? nil : true 15021 self.pos = _save4 15022 unless _tmp 15023 self.pos = _save3 15024 break 15025 end 15026 _save5 = self.pos 15027 _tmp = apply(:_SetextBottom1) 15028 _tmp = _tmp ? nil : true 15029 self.pos = _save5 15030 unless _tmp 15031 self.pos = _save3 15032 break 15033 end 15034 _save6 = self.pos 15035 _tmp = apply(:_SetextBottom2) 15036 _tmp = _tmp ? nil : true 15037 self.pos = _save6 15038 unless _tmp 15039 self.pos = _save3 15040 break 15041 end 15042 _save7 = self.pos 15043 _tmp = apply(:_BlankLine) 15044 _tmp = _tmp ? nil : true 15045 self.pos = _save7 15046 unless _tmp 15047 self.pos = _save3 15048 break 15049 end 15050 _tmp = apply(:_RawLine) 15051 unless _tmp 15052 self.pos = _save3 15053 end 15054 break 15055 end # end sequence 15056 15057 if _tmp 15058 while true 15059 15060 _save8 = self.pos 15061 while true # sequence 15062 _save9 = self.pos 15063 _tmp = match_string("#") 15064 _tmp = _tmp ? nil : true 15065 self.pos = _save9 15066 unless _tmp 15067 self.pos = _save8 15068 break 15069 end 15070 _save10 = self.pos 15071 _tmp = apply(:_SetextBottom1) 15072 _tmp = _tmp ? nil : true 15073 self.pos = _save10 15074 unless _tmp 15075 self.pos = _save8 15076 break 15077 end 15078 _save11 = self.pos 15079 _tmp = apply(:_SetextBottom2) 15080 _tmp = _tmp ? nil : true 15081 self.pos = _save11 15082 unless _tmp 15083 self.pos = _save8 15084 break 15085 end 15086 _save12 = self.pos 15087 _tmp = apply(:_BlankLine) 15088 _tmp = _tmp ? nil : true 15089 self.pos = _save12 15090 unless _tmp 15091 self.pos = _save8 15092 break 15093 end 15094 _tmp = apply(:_RawLine) 15095 unless _tmp 15096 self.pos = _save8 15097 end 15098 break 15099 end # end sequence 15100 15101 break unless _tmp 15102 end 15103 _tmp = true 15104 else 15105 self.pos = _save2 15106 end 15107 unless _tmp 15108 self.pos = _save1 15109 break 15110 end 15111 while true 15112 _tmp = apply(:_BlankLine) 15113 break unless _tmp 15114 end 15115 _tmp = true 15116 unless _tmp 15117 self.pos = _save1 15118 end 15119 break 15120 end # end sequence 15121 15122 break if _tmp 15123 self.pos = _save 15124 _save14 = self.pos 15125 _tmp = apply(:_BlankLine) 15126 if _tmp 15127 while true 15128 _tmp = apply(:_BlankLine) 15129 break unless _tmp 15130 end 15131 _tmp = true 15132 else 15133 self.pos = _save14 15134 end 15135 break if _tmp 15136 self.pos = _save 15137 _tmp = apply(:_RawLine) 15138 break if _tmp 15139 self.pos = _save 15140 break 15141 end # end choice 15142 15143 set_failed_rule :_SkipBlock unless _tmp 15144 return _tmp 15145 end 15146 15147 # ExtendedSpecialChar = &{ notes? } "^" 15148 def _ExtendedSpecialChar 15149 15150 _save = self.pos 15151 while true # sequence 15152 _save1 = self.pos 15153 _tmp = begin; notes? ; end 15154 self.pos = _save1 15155 unless _tmp 15156 self.pos = _save 15157 break 15158 end 15159 _tmp = match_string("^") 15160 unless _tmp 15161 self.pos = _save 15162 end 15163 break 15164 end # end sequence 15165 15166 set_failed_rule :_ExtendedSpecialChar unless _tmp 15167 return _tmp 15168 end 15169 15170 # NoteReference = &{ notes? } RawNoteReference:ref { note_for ref } 15171 def _NoteReference 15172 15173 _save = self.pos 15174 while true # sequence 15175 _save1 = self.pos 15176 _tmp = begin; notes? ; end 15177 self.pos = _save1 15178 unless _tmp 15179 self.pos = _save 15180 break 15181 end 15182 _tmp = apply(:_RawNoteReference) 15183 ref = @result 15184 unless _tmp 15185 self.pos = _save 15186 break 15187 end 15188 @result = begin; note_for ref ; end 15189 _tmp = true 15190 unless _tmp 15191 self.pos = _save 15192 end 15193 break 15194 end # end sequence 15195 15196 set_failed_rule :_NoteReference unless _tmp 15197 return _tmp 15198 end 15199 15200 # RawNoteReference = "[^" < (!Newline !"]" .)+ > "]" { text } 15201 def _RawNoteReference 15202 15203 _save = self.pos 15204 while true # sequence 15205 _tmp = match_string("[^") 15206 unless _tmp 15207 self.pos = _save 15208 break 15209 end 15210 _text_start = self.pos 15211 _save1 = self.pos 15212 15213 _save2 = self.pos 15214 while true # sequence 15215 _save3 = self.pos 15216 _tmp = apply(:_Newline) 15217 _tmp = _tmp ? nil : true 15218 self.pos = _save3 15219 unless _tmp 15220 self.pos = _save2 15221 break 15222 end 15223 _save4 = self.pos 15224 _tmp = match_string("]") 15225 _tmp = _tmp ? nil : true 15226 self.pos = _save4 15227 unless _tmp 15228 self.pos = _save2 15229 break 15230 end 15231 _tmp = get_byte 15232 unless _tmp 15233 self.pos = _save2 15234 end 15235 break 15236 end # end sequence 15237 15238 if _tmp 15239 while true 15240 15241 _save5 = self.pos 15242 while true # sequence 15243 _save6 = self.pos 15244 _tmp = apply(:_Newline) 15245 _tmp = _tmp ? nil : true 15246 self.pos = _save6 15247 unless _tmp 15248 self.pos = _save5 15249 break 15250 end 15251 _save7 = self.pos 15252 _tmp = match_string("]") 15253 _tmp = _tmp ? nil : true 15254 self.pos = _save7 15255 unless _tmp 15256 self.pos = _save5 15257 break 15258 end 15259 _tmp = get_byte 15260 unless _tmp 15261 self.pos = _save5 15262 end 15263 break 15264 end # end sequence 15265 15266 break unless _tmp 15267 end 15268 _tmp = true 15269 else 15270 self.pos = _save1 15271 end 15272 if _tmp 15273 text = get_text(_text_start) 15274 end 15275 unless _tmp 15276 self.pos = _save 15277 break 15278 end 15279 _tmp = match_string("]") 15280 unless _tmp 15281 self.pos = _save 15282 break 15283 end 15284 @result = begin; text ; end 15285 _tmp = true 15286 unless _tmp 15287 self.pos = _save 15288 end 15289 break 15290 end # end sequence 15291 15292 set_failed_rule :_RawNoteReference unless _tmp 15293 return _tmp 15294 end 15295 15296 # Note = &{ notes? } NonindentSpace RawNoteReference:ref ":" Sp StartList:a RawNoteBlock (&Indent RawNoteBlock:i { a.concat i })* { @footnotes[ref] = paragraph a nil } 15297 def _Note 15298 15299 _save = self.pos 15300 while true # sequence 15301 _save1 = self.pos 15302 _tmp = begin; notes? ; end 15303 self.pos = _save1 15304 unless _tmp 15305 self.pos = _save 15306 break 15307 end 15308 _tmp = apply(:_NonindentSpace) 15309 unless _tmp 15310 self.pos = _save 15311 break 15312 end 15313 _tmp = apply(:_RawNoteReference) 15314 ref = @result 15315 unless _tmp 15316 self.pos = _save 15317 break 15318 end 15319 _tmp = match_string(":") 15320 unless _tmp 15321 self.pos = _save 15322 break 15323 end 15324 _tmp = apply(:_Sp) 15325 unless _tmp 15326 self.pos = _save 15327 break 15328 end 15329 _tmp = apply(:_StartList) 15330 a = @result 15331 unless _tmp 15332 self.pos = _save 15333 break 15334 end 15335 _tmp = apply(:_RawNoteBlock) 15336 unless _tmp 15337 self.pos = _save 15338 break 15339 end 15340 while true 15341 15342 _save3 = self.pos 15343 while true # sequence 15344 _save4 = self.pos 15345 _tmp = apply(:_Indent) 15346 self.pos = _save4 15347 unless _tmp 15348 self.pos = _save3 15349 break 15350 end 15351 _tmp = apply(:_RawNoteBlock) 15352 i = @result 15353 unless _tmp 15354 self.pos = _save3 15355 break 15356 end 15357 @result = begin; a.concat i ; end 15358 _tmp = true 15359 unless _tmp 15360 self.pos = _save3 15361 end 15362 break 15363 end # end sequence 15364 15365 break unless _tmp 15366 end 15367 _tmp = true 15368 unless _tmp 15369 self.pos = _save 15370 break 15371 end 15372 @result = begin; @footnotes[ref] = paragraph a 15373 15374 nil 15375 ; end 15376 _tmp = true 15377 unless _tmp 15378 self.pos = _save 15379 end 15380 break 15381 end # end sequence 15382 15383 set_failed_rule :_Note unless _tmp 15384 return _tmp 15385 end 15386 15387 # InlineNote = &{ notes? } "^[" StartList:a (!"]" Inline:l { a << l })+ "]" { ref = [:inline, @note_order.length] @footnotes[ref] = paragraph a note_for ref } 15388 def _InlineNote 15389 15390 _save = self.pos 15391 while true # sequence 15392 _save1 = self.pos 15393 _tmp = begin; notes? ; end 15394 self.pos = _save1 15395 unless _tmp 15396 self.pos = _save 15397 break 15398 end 15399 _tmp = match_string("^[") 15400 unless _tmp 15401 self.pos = _save 15402 break 15403 end 15404 _tmp = apply(:_StartList) 15405 a = @result 15406 unless _tmp 15407 self.pos = _save 15408 break 15409 end 15410 _save2 = self.pos 15411 15412 _save3 = self.pos 15413 while true # sequence 15414 _save4 = self.pos 15415 _tmp = match_string("]") 15416 _tmp = _tmp ? nil : true 15417 self.pos = _save4 15418 unless _tmp 15419 self.pos = _save3 15420 break 15421 end 15422 _tmp = apply(:_Inline) 15423 l = @result 15424 unless _tmp 15425 self.pos = _save3 15426 break 15427 end 15428 @result = begin; a << l ; end 15429 _tmp = true 15430 unless _tmp 15431 self.pos = _save3 15432 end 15433 break 15434 end # end sequence 15435 15436 if _tmp 15437 while true 15438 15439 _save5 = self.pos 15440 while true # sequence 15441 _save6 = self.pos 15442 _tmp = match_string("]") 15443 _tmp = _tmp ? nil : true 15444 self.pos = _save6 15445 unless _tmp 15446 self.pos = _save5 15447 break 15448 end 15449 _tmp = apply(:_Inline) 15450 l = @result 15451 unless _tmp 15452 self.pos = _save5 15453 break 15454 end 15455 @result = begin; a << l ; end 15456 _tmp = true 15457 unless _tmp 15458 self.pos = _save5 15459 end 15460 break 15461 end # end sequence 15462 15463 break unless _tmp 15464 end 15465 _tmp = true 15466 else 15467 self.pos = _save2 15468 end 15469 unless _tmp 15470 self.pos = _save 15471 break 15472 end 15473 _tmp = match_string("]") 15474 unless _tmp 15475 self.pos = _save 15476 break 15477 end 15478 @result = begin; 15479 ref = [:inline, @note_order.length] 15480 @footnotes[ref] = paragraph a 15481 15482 note_for ref 15483 ; end 15484 _tmp = true 15485 unless _tmp 15486 self.pos = _save 15487 end 15488 break 15489 end # end sequence 15490 15491 set_failed_rule :_InlineNote unless _tmp 15492 return _tmp 15493 end 15494 15495 # Notes = (Note | SkipBlock)* 15496 def _Notes 15497 while true 15498 15499 _save1 = self.pos 15500 while true # choice 15501 _tmp = apply(:_Note) 15502 break if _tmp 15503 self.pos = _save1 15504 _tmp = apply(:_SkipBlock) 15505 break if _tmp 15506 self.pos = _save1 15507 break 15508 end # end choice 15509 15510 break unless _tmp 15511 end 15512 _tmp = true 15513 set_failed_rule :_Notes unless _tmp 15514 return _tmp 15515 end 15516 15517 # RawNoteBlock = StartList:a (!BlankLine OptionallyIndentedLine:l { a << l })+ < BlankLine* > { a << text } { a } 15518 def _RawNoteBlock 15519 15520 _save = self.pos 15521 while true # sequence 15522 _tmp = apply(:_StartList) 15523 a = @result 15524 unless _tmp 15525 self.pos = _save 15526 break 15527 end 15528 _save1 = self.pos 15529 15530 _save2 = self.pos 15531 while true # sequence 15532 _save3 = self.pos 15533 _tmp = apply(:_BlankLine) 15534 _tmp = _tmp ? nil : true 15535 self.pos = _save3 15536 unless _tmp 15537 self.pos = _save2 15538 break 15539 end 15540 _tmp = apply(:_OptionallyIndentedLine) 15541 l = @result 15542 unless _tmp 15543 self.pos = _save2 15544 break 15545 end 15546 @result = begin; a << l ; end 15547 _tmp = true 15548 unless _tmp 15549 self.pos = _save2 15550 end 15551 break 15552 end # end sequence 15553 15554 if _tmp 15555 while true 15556 15557 _save4 = self.pos 15558 while true # sequence 15559 _save5 = self.pos 15560 _tmp = apply(:_BlankLine) 15561 _tmp = _tmp ? nil : true 15562 self.pos = _save5 15563 unless _tmp 15564 self.pos = _save4 15565 break 15566 end 15567 _tmp = apply(:_OptionallyIndentedLine) 15568 l = @result 15569 unless _tmp 15570 self.pos = _save4 15571 break 15572 end 15573 @result = begin; a << l ; end 15574 _tmp = true 15575 unless _tmp 15576 self.pos = _save4 15577 end 15578 break 15579 end # end sequence 15580 15581 break unless _tmp 15582 end 15583 _tmp = true 15584 else 15585 self.pos = _save1 15586 end 15587 unless _tmp 15588 self.pos = _save 15589 break 15590 end 15591 _text_start = self.pos 15592 while true 15593 _tmp = apply(:_BlankLine) 15594 break unless _tmp 15595 end 15596 _tmp = true 15597 if _tmp 15598 text = get_text(_text_start) 15599 end 15600 unless _tmp 15601 self.pos = _save 15602 break 15603 end 15604 @result = begin; a << text ; end 15605 _tmp = true 15606 unless _tmp 15607 self.pos = _save 15608 break 15609 end 15610 @result = begin; a ; end 15611 _tmp = true 15612 unless _tmp 15613 self.pos = _save 15614 end 15615 break 15616 end # end sequence 15617 15618 set_failed_rule :_RawNoteBlock unless _tmp 15619 return _tmp 15620 end 15621 15622 # CodeFence = &{ github? } Ticks3 (Sp StrChunk:format)? Spnl < ((!"`" Nonspacechar)+ | !Ticks3 "`"+ | Spacechar | Newline)+ > Ticks3 Sp Newline* { verbatim = RDoc::Markup::Verbatim.new text verbatim.format = format.intern if format verbatim } 15623 def _CodeFence 15624 15625 _save = self.pos 15626 while true # sequence 15627 _save1 = self.pos 15628 _tmp = begin; github? ; end 15629 self.pos = _save1 15630 unless _tmp 15631 self.pos = _save 15632 break 15633 end 15634 _tmp = apply(:_Ticks3) 15635 unless _tmp 15636 self.pos = _save 15637 break 15638 end 15639 _save2 = self.pos 15640 15641 _save3 = self.pos 15642 while true # sequence 15643 _tmp = apply(:_Sp) 15644 unless _tmp 15645 self.pos = _save3 15646 break 15647 end 15648 _tmp = apply(:_StrChunk) 15649 format = @result 15650 unless _tmp 15651 self.pos = _save3 15652 end 15653 break 15654 end # end sequence 15655 15656 unless _tmp 15657 _tmp = true 15658 self.pos = _save2 15659 end 15660 unless _tmp 15661 self.pos = _save 15662 break 15663 end 15664 _tmp = apply(:_Spnl) 15665 unless _tmp 15666 self.pos = _save 15667 break 15668 end 15669 _text_start = self.pos 15670 _save4 = self.pos 15671 15672 _save5 = self.pos 15673 while true # choice 15674 _save6 = self.pos 15675 15676 _save7 = self.pos 15677 while true # sequence 15678 _save8 = self.pos 15679 _tmp = match_string("`") 15680 _tmp = _tmp ? nil : true 15681 self.pos = _save8 15682 unless _tmp 15683 self.pos = _save7 15684 break 15685 end 15686 _tmp = apply(:_Nonspacechar) 15687 unless _tmp 15688 self.pos = _save7 15689 end 15690 break 15691 end # end sequence 15692 15693 if _tmp 15694 while true 15695 15696 _save9 = self.pos 15697 while true # sequence 15698 _save10 = self.pos 15699 _tmp = match_string("`") 15700 _tmp = _tmp ? nil : true 15701 self.pos = _save10 15702 unless _tmp 15703 self.pos = _save9 15704 break 15705 end 15706 _tmp = apply(:_Nonspacechar) 15707 unless _tmp 15708 self.pos = _save9 15709 end 15710 break 15711 end # end sequence 15712 15713 break unless _tmp 15714 end 15715 _tmp = true 15716 else 15717 self.pos = _save6 15718 end 15719 break if _tmp 15720 self.pos = _save5 15721 15722 _save11 = self.pos 15723 while true # sequence 15724 _save12 = self.pos 15725 _tmp = apply(:_Ticks3) 15726 _tmp = _tmp ? nil : true 15727 self.pos = _save12 15728 unless _tmp 15729 self.pos = _save11 15730 break 15731 end 15732 _save13 = self.pos 15733 _tmp = match_string("`") 15734 if _tmp 15735 while true 15736 _tmp = match_string("`") 15737 break unless _tmp 15738 end 15739 _tmp = true 15740 else 15741 self.pos = _save13 15742 end 15743 unless _tmp 15744 self.pos = _save11 15745 end 15746 break 15747 end # end sequence 15748 15749 break if _tmp 15750 self.pos = _save5 15751 _tmp = apply(:_Spacechar) 15752 break if _tmp 15753 self.pos = _save5 15754 _tmp = apply(:_Newline) 15755 break if _tmp 15756 self.pos = _save5 15757 break 15758 end # end choice 15759 15760 if _tmp 15761 while true 15762 15763 _save14 = self.pos 15764 while true # choice 15765 _save15 = self.pos 15766 15767 _save16 = self.pos 15768 while true # sequence 15769 _save17 = self.pos 15770 _tmp = match_string("`") 15771 _tmp = _tmp ? nil : true 15772 self.pos = _save17 15773 unless _tmp 15774 self.pos = _save16 15775 break 15776 end 15777 _tmp = apply(:_Nonspacechar) 15778 unless _tmp 15779 self.pos = _save16 15780 end 15781 break 15782 end # end sequence 15783 15784 if _tmp 15785 while true 15786 15787 _save18 = self.pos 15788 while true # sequence 15789 _save19 = self.pos 15790 _tmp = match_string("`") 15791 _tmp = _tmp ? nil : true 15792 self.pos = _save19 15793 unless _tmp 15794 self.pos = _save18 15795 break 15796 end 15797 _tmp = apply(:_Nonspacechar) 15798 unless _tmp 15799 self.pos = _save18 15800 end 15801 break 15802 end # end sequence 15803 15804 break unless _tmp 15805 end 15806 _tmp = true 15807 else 15808 self.pos = _save15 15809 end 15810 break if _tmp 15811 self.pos = _save14 15812 15813 _save20 = self.pos 15814 while true # sequence 15815 _save21 = self.pos 15816 _tmp = apply(:_Ticks3) 15817 _tmp = _tmp ? nil : true 15818 self.pos = _save21 15819 unless _tmp 15820 self.pos = _save20 15821 break 15822 end 15823 _save22 = self.pos 15824 _tmp = match_string("`") 15825 if _tmp 15826 while true 15827 _tmp = match_string("`") 15828 break unless _tmp 15829 end 15830 _tmp = true 15831 else 15832 self.pos = _save22 15833 end 15834 unless _tmp 15835 self.pos = _save20 15836 end 15837 break 15838 end # end sequence 15839 15840 break if _tmp 15841 self.pos = _save14 15842 _tmp = apply(:_Spacechar) 15843 break if _tmp 15844 self.pos = _save14 15845 _tmp = apply(:_Newline) 15846 break if _tmp 15847 self.pos = _save14 15848 break 15849 end # end choice 15850 15851 break unless _tmp 15852 end 15853 _tmp = true 15854 else 15855 self.pos = _save4 15856 end 15857 if _tmp 15858 text = get_text(_text_start) 15859 end 15860 unless _tmp 15861 self.pos = _save 15862 break 15863 end 15864 _tmp = apply(:_Ticks3) 15865 unless _tmp 15866 self.pos = _save 15867 break 15868 end 15869 _tmp = apply(:_Sp) 15870 unless _tmp 15871 self.pos = _save 15872 break 15873 end 15874 while true 15875 _tmp = apply(:_Newline) 15876 break unless _tmp 15877 end 15878 _tmp = true 15879 unless _tmp 15880 self.pos = _save 15881 break 15882 end 15883 @result = begin; verbatim = RDoc::Markup::Verbatim.new text 15884 verbatim.format = format.intern if format 15885 verbatim 15886 ; end 15887 _tmp = true 15888 unless _tmp 15889 self.pos = _save 15890 end 15891 break 15892 end # end sequence 15893 15894 set_failed_rule :_CodeFence unless _tmp 15895 return _tmp 15896 end 15897 15898 # DefinitionList = &{ definition_lists? } DefinitionListItem+:list { RDoc::Markup::List.new :NOTE, *list.flatten } 15899 def _DefinitionList 15900 15901 _save = self.pos 15902 while true # sequence 15903 _save1 = self.pos 15904 _tmp = begin; definition_lists? ; end 15905 self.pos = _save1 15906 unless _tmp 15907 self.pos = _save 15908 break 15909 end 15910 _save2 = self.pos 15911 _ary = [] 15912 _tmp = apply(:_DefinitionListItem) 15913 if _tmp 15914 _ary << @result 15915 while true 15916 _tmp = apply(:_DefinitionListItem) 15917 _ary << @result if _tmp 15918 break unless _tmp 15919 end 15920 _tmp = true 15921 @result = _ary 15922 else 15923 self.pos = _save2 15924 end 15925 list = @result 15926 unless _tmp 15927 self.pos = _save 15928 break 15929 end 15930 @result = begin; RDoc::Markup::List.new :NOTE, *list.flatten ; end 15931 _tmp = true 15932 unless _tmp 15933 self.pos = _save 15934 end 15935 break 15936 end # end sequence 15937 15938 set_failed_rule :_DefinitionList unless _tmp 15939 return _tmp 15940 end 15941 15942 # DefinitionListItem = DefinitionListLabel+:label DefinitionListDefinition+:defns { list_items = [] list_items << RDoc::Markup::ListItem.new(label, defns.shift) list_items.concat defns.map { |defn| RDoc::Markup::ListItem.new nil, defn } unless list_items.empty? list_items } 15943 def _DefinitionListItem 15944 15945 _save = self.pos 15946 while true # sequence 15947 _save1 = self.pos 15948 _ary = [] 15949 _tmp = apply(:_DefinitionListLabel) 15950 if _tmp 15951 _ary << @result 15952 while true 15953 _tmp = apply(:_DefinitionListLabel) 15954 _ary << @result if _tmp 15955 break unless _tmp 15956 end 15957 _tmp = true 15958 @result = _ary 15959 else 15960 self.pos = _save1 15961 end 15962 label = @result 15963 unless _tmp 15964 self.pos = _save 15965 break 15966 end 15967 _save2 = self.pos 15968 _ary = [] 15969 _tmp = apply(:_DefinitionListDefinition) 15970 if _tmp 15971 _ary << @result 15972 while true 15973 _tmp = apply(:_DefinitionListDefinition) 15974 _ary << @result if _tmp 15975 break unless _tmp 15976 end 15977 _tmp = true 15978 @result = _ary 15979 else 15980 self.pos = _save2 15981 end 15982 defns = @result 15983 unless _tmp 15984 self.pos = _save 15985 break 15986 end 15987 @result = begin; list_items = [] 15988 list_items << 15989 RDoc::Markup::ListItem.new(label, defns.shift) 15990 15991 list_items.concat defns.map { |defn| 15992 RDoc::Markup::ListItem.new nil, defn 15993 } unless list_items.empty? 15994 15995 list_items 15996 ; end 15997 _tmp = true 15998 unless _tmp 15999 self.pos = _save 16000 end 16001 break 16002 end # end sequence 16003 16004 set_failed_rule :_DefinitionListItem unless _tmp 16005 return _tmp 16006 end 16007 16008 # DefinitionListLabel = StrChunk:label Sp Newline { label } 16009 def _DefinitionListLabel 16010 16011 _save = self.pos 16012 while true # sequence 16013 _tmp = apply(:_StrChunk) 16014 label = @result 16015 unless _tmp 16016 self.pos = _save 16017 break 16018 end 16019 _tmp = apply(:_Sp) 16020 unless _tmp 16021 self.pos = _save 16022 break 16023 end 16024 _tmp = apply(:_Newline) 16025 unless _tmp 16026 self.pos = _save 16027 break 16028 end 16029 @result = begin; label ; end 16030 _tmp = true 16031 unless _tmp 16032 self.pos = _save 16033 end 16034 break 16035 end # end sequence 16036 16037 set_failed_rule :_DefinitionListLabel unless _tmp 16038 return _tmp 16039 end 16040 16041 # DefinitionListDefinition = NonindentSpace ":" Space Inlines:a BlankLine+ { paragraph a } 16042 def _DefinitionListDefinition 16043 16044 _save = self.pos 16045 while true # sequence 16046 _tmp = apply(:_NonindentSpace) 16047 unless _tmp 16048 self.pos = _save 16049 break 16050 end 16051 _tmp = match_string(":") 16052 unless _tmp 16053 self.pos = _save 16054 break 16055 end 16056 _tmp = apply(:_Space) 16057 unless _tmp 16058 self.pos = _save 16059 break 16060 end 16061 _tmp = apply(:_Inlines) 16062 a = @result 16063 unless _tmp 16064 self.pos = _save 16065 break 16066 end 16067 _save1 = self.pos 16068 _tmp = apply(:_BlankLine) 16069 if _tmp 16070 while true 16071 _tmp = apply(:_BlankLine) 16072 break unless _tmp 16073 end 16074 _tmp = true 16075 else 16076 self.pos = _save1 16077 end 16078 unless _tmp 16079 self.pos = _save 16080 break 16081 end 16082 @result = begin; paragraph a ; end 16083 _tmp = true 16084 unless _tmp 16085 self.pos = _save 16086 end 16087 break 16088 end # end sequence 16089 16090 set_failed_rule :_DefinitionListDefinition unless _tmp 16091 return _tmp 16092 end 16093 16094 Rules = {} 16095 Rules[:_root] = rule_info("root", "Doc") 16096 Rules[:_Doc] = rule_info("Doc", "BOM? Block*:a { RDoc::Markup::Document.new(*a.compact) }") 16097 Rules[:_Block] = rule_info("Block", "BlankLine* (BlockQuote | Verbatim | CodeFence | Note | Reference | HorizontalRule | Heading | OrderedList | BulletList | DefinitionList | HtmlBlock | StyleBlock | Para | Plain)") 16098 Rules[:_Para] = rule_info("Para", "NonindentSpace Inlines:a BlankLine+ { paragraph a }") 16099 Rules[:_Plain] = rule_info("Plain", "Inlines:a { paragraph a }") 16100 Rules[:_AtxInline] = rule_info("AtxInline", "!Newline !(Sp? \"\#\"* Sp Newline) Inline") 16101 Rules[:_AtxStart] = rule_info("AtxStart", "< (\"\#\#\#\#\#\#\" | \"\#\#\#\#\#\" | \"\#\#\#\#\" | \"\#\#\#\" | \"\#\#\" | \"\#\") > { text.length }") 16102 Rules[:_AtxHeading] = rule_info("AtxHeading", "AtxStart:s Sp? AtxInline+:a (Sp? \"\#\"* Sp)? Newline { RDoc::Markup::Heading.new(s, a.join) }") 16103 Rules[:_SetextHeading] = rule_info("SetextHeading", "(SetextHeading1 | SetextHeading2)") 16104 Rules[:_SetextBottom1] = rule_info("SetextBottom1", "\"===\" \"=\"* Newline") 16105 Rules[:_SetextBottom2] = rule_info("SetextBottom2", "\"---\" \"-\"* Newline") 16106 Rules[:_SetextHeading1] = rule_info("SetextHeading1", "&(RawLine SetextBottom1) StartList:a (!Endline Inline:b { a << b })+ Sp? Newline SetextBottom1 { RDoc::Markup::Heading.new(1, a.join) }") 16107 Rules[:_SetextHeading2] = rule_info("SetextHeading2", "&(RawLine SetextBottom2) StartList:a (!Endline Inline:b { a << b })+ Sp? Newline SetextBottom2 { RDoc::Markup::Heading.new(2, a.join) }") 16108 Rules[:_Heading] = rule_info("Heading", "(SetextHeading | AtxHeading)") 16109 Rules[:_BlockQuote] = rule_info("BlockQuote", "BlockQuoteRaw:a { RDoc::Markup::BlockQuote.new(*a) }") 16110 Rules[:_BlockQuoteRaw] = rule_info("BlockQuoteRaw", "StartList:a (\">\" \" \"? Line:l { a << l } (!\">\" !BlankLine Line:c { a << c })* (BlankLine:n { a << n })*)+ { inner_parse a.join }") 16111 Rules[:_NonblankIndentedLine] = rule_info("NonblankIndentedLine", "!BlankLine IndentedLine") 16112 Rules[:_VerbatimChunk] = rule_info("VerbatimChunk", "BlankLine*:a NonblankIndentedLine+:b { a.concat b }") 16113 Rules[:_Verbatim] = rule_info("Verbatim", "VerbatimChunk+:a { RDoc::Markup::Verbatim.new(*a.flatten) }") 16114 Rules[:_HorizontalRule] = rule_info("HorizontalRule", "NonindentSpace (\"*\" Sp \"*\" Sp \"*\" (Sp \"*\")* | \"-\" Sp \"-\" Sp \"-\" (Sp \"-\")* | \"_\" Sp \"_\" Sp \"_\" (Sp \"_\")*) Sp Newline BlankLine+ { RDoc::Markup::Rule.new 1 }") 16115 Rules[:_Bullet] = rule_info("Bullet", "!HorizontalRule NonindentSpace (\"+\" | \"*\" | \"-\") Spacechar+") 16116 Rules[:_BulletList] = rule_info("BulletList", "&Bullet (ListTight | ListLoose):a { RDoc::Markup::List.new(:BULLET, *a) }") 16117 Rules[:_ListTight] = rule_info("ListTight", "ListItemTight+:a BlankLine* !(Bullet | Enumerator) { a }") 16118 Rules[:_ListLoose] = rule_info("ListLoose", "StartList:a (ListItem:b BlankLine* { a << b })+ { a }") 16119 Rules[:_ListItem] = rule_info("ListItem", "(Bullet | Enumerator) StartList:a ListBlock:b { a << b } (ListContinuationBlock:c { a.push(*c) })* { list_item_from a }") 16120 Rules[:_ListItemTight] = rule_info("ListItemTight", "(Bullet | Enumerator) ListBlock:a (!BlankLine ListContinuationBlock:b { a.push(*b) })* !ListContinuationBlock { list_item_from a }") 16121 Rules[:_ListBlock] = rule_info("ListBlock", "!BlankLine Line:a ListBlockLine*:c { [a, *c] }") 16122 Rules[:_ListContinuationBlock] = rule_info("ListContinuationBlock", "StartList:a BlankLine* { a << \"\\n\" } (Indent ListBlock:b { a.concat b })+ { a }") 16123 Rules[:_Enumerator] = rule_info("Enumerator", "NonindentSpace [0-9]+ \".\" Spacechar+") 16124 Rules[:_OrderedList] = rule_info("OrderedList", "&Enumerator (ListTight | ListLoose):a { RDoc::Markup::List.new(:NUMBER, *a) }") 16125 Rules[:_ListBlockLine] = rule_info("ListBlockLine", "!BlankLine !(Indent? (Bullet | Enumerator)) !HorizontalRule OptionallyIndentedLine") 16126 Rules[:_HtmlBlockOpenAddress] = rule_info("HtmlBlockOpenAddress", "\"<\" Spnl (\"address\" | \"ADDRESS\") Spnl HtmlAttribute* \">\"") 16127 Rules[:_HtmlBlockCloseAddress] = rule_info("HtmlBlockCloseAddress", "\"<\" Spnl \"/\" (\"address\" | \"ADDRESS\") Spnl \">\"") 16128 Rules[:_HtmlBlockAddress] = rule_info("HtmlBlockAddress", "HtmlBlockOpenAddress (HtmlBlockAddress | !HtmlBlockCloseAddress .)* HtmlBlockCloseAddress") 16129 Rules[:_HtmlBlockOpenBlockquote] = rule_info("HtmlBlockOpenBlockquote", "\"<\" Spnl (\"blockquote\" | \"BLOCKQUOTE\") Spnl HtmlAttribute* \">\"") 16130 Rules[:_HtmlBlockCloseBlockquote] = rule_info("HtmlBlockCloseBlockquote", "\"<\" Spnl \"/\" (\"blockquote\" | \"BLOCKQUOTE\") Spnl \">\"") 16131 Rules[:_HtmlBlockBlockquote] = rule_info("HtmlBlockBlockquote", "HtmlBlockOpenBlockquote (HtmlBlockBlockquote | !HtmlBlockCloseBlockquote .)* HtmlBlockCloseBlockquote") 16132 Rules[:_HtmlBlockOpenCenter] = rule_info("HtmlBlockOpenCenter", "\"<\" Spnl (\"center\" | \"CENTER\") Spnl HtmlAttribute* \">\"") 16133 Rules[:_HtmlBlockCloseCenter] = rule_info("HtmlBlockCloseCenter", "\"<\" Spnl \"/\" (\"center\" | \"CENTER\") Spnl \">\"") 16134 Rules[:_HtmlBlockCenter] = rule_info("HtmlBlockCenter", "HtmlBlockOpenCenter (HtmlBlockCenter | !HtmlBlockCloseCenter .)* HtmlBlockCloseCenter") 16135 Rules[:_HtmlBlockOpenDir] = rule_info("HtmlBlockOpenDir", "\"<\" Spnl (\"dir\" | \"DIR\") Spnl HtmlAttribute* \">\"") 16136 Rules[:_HtmlBlockCloseDir] = rule_info("HtmlBlockCloseDir", "\"<\" Spnl \"/\" (\"dir\" | \"DIR\") Spnl \">\"") 16137 Rules[:_HtmlBlockDir] = rule_info("HtmlBlockDir", "HtmlBlockOpenDir (HtmlBlockDir | !HtmlBlockCloseDir .)* HtmlBlockCloseDir") 16138 Rules[:_HtmlBlockOpenDiv] = rule_info("HtmlBlockOpenDiv", "\"<\" Spnl (\"div\" | \"DIV\") Spnl HtmlAttribute* \">\"") 16139 Rules[:_HtmlBlockCloseDiv] = rule_info("HtmlBlockCloseDiv", "\"<\" Spnl \"/\" (\"div\" | \"DIV\") Spnl \">\"") 16140 Rules[:_HtmlBlockDiv] = rule_info("HtmlBlockDiv", "HtmlBlockOpenDiv (HtmlBlockDiv | !HtmlBlockCloseDiv .)* HtmlBlockCloseDiv") 16141 Rules[:_HtmlBlockOpenDl] = rule_info("HtmlBlockOpenDl", "\"<\" Spnl (\"dl\" | \"DL\") Spnl HtmlAttribute* \">\"") 16142 Rules[:_HtmlBlockCloseDl] = rule_info("HtmlBlockCloseDl", "\"<\" Spnl \"/\" (\"dl\" | \"DL\") Spnl \">\"") 16143 Rules[:_HtmlBlockDl] = rule_info("HtmlBlockDl", "HtmlBlockOpenDl (HtmlBlockDl | !HtmlBlockCloseDl .)* HtmlBlockCloseDl") 16144 Rules[:_HtmlBlockOpenFieldset] = rule_info("HtmlBlockOpenFieldset", "\"<\" Spnl (\"fieldset\" | \"FIELDSET\") Spnl HtmlAttribute* \">\"") 16145 Rules[:_HtmlBlockCloseFieldset] = rule_info("HtmlBlockCloseFieldset", "\"<\" Spnl \"/\" (\"fieldset\" | \"FIELDSET\") Spnl \">\"") 16146 Rules[:_HtmlBlockFieldset] = rule_info("HtmlBlockFieldset", "HtmlBlockOpenFieldset (HtmlBlockFieldset | !HtmlBlockCloseFieldset .)* HtmlBlockCloseFieldset") 16147 Rules[:_HtmlBlockOpenForm] = rule_info("HtmlBlockOpenForm", "\"<\" Spnl (\"form\" | \"FORM\") Spnl HtmlAttribute* \">\"") 16148 Rules[:_HtmlBlockCloseForm] = rule_info("HtmlBlockCloseForm", "\"<\" Spnl \"/\" (\"form\" | \"FORM\") Spnl \">\"") 16149 Rules[:_HtmlBlockForm] = rule_info("HtmlBlockForm", "HtmlBlockOpenForm (HtmlBlockForm | !HtmlBlockCloseForm .)* HtmlBlockCloseForm") 16150 Rules[:_HtmlBlockOpenH1] = rule_info("HtmlBlockOpenH1", "\"<\" Spnl (\"h1\" | \"H1\") Spnl HtmlAttribute* \">\"") 16151 Rules[:_HtmlBlockCloseH1] = rule_info("HtmlBlockCloseH1", "\"<\" Spnl \"/\" (\"h1\" | \"H1\") Spnl \">\"") 16152 Rules[:_HtmlBlockH1] = rule_info("HtmlBlockH1", "HtmlBlockOpenH1 (HtmlBlockH1 | !HtmlBlockCloseH1 .)* HtmlBlockCloseH1") 16153 Rules[:_HtmlBlockOpenH2] = rule_info("HtmlBlockOpenH2", "\"<\" Spnl (\"h2\" | \"H2\") Spnl HtmlAttribute* \">\"") 16154 Rules[:_HtmlBlockCloseH2] = rule_info("HtmlBlockCloseH2", "\"<\" Spnl \"/\" (\"h2\" | \"H2\") Spnl \">\"") 16155 Rules[:_HtmlBlockH2] = rule_info("HtmlBlockH2", "HtmlBlockOpenH2 (HtmlBlockH2 | !HtmlBlockCloseH2 .)* HtmlBlockCloseH2") 16156 Rules[:_HtmlBlockOpenH3] = rule_info("HtmlBlockOpenH3", "\"<\" Spnl (\"h3\" | \"H3\") Spnl HtmlAttribute* \">\"") 16157 Rules[:_HtmlBlockCloseH3] = rule_info("HtmlBlockCloseH3", "\"<\" Spnl \"/\" (\"h3\" | \"H3\") Spnl \">\"") 16158 Rules[:_HtmlBlockH3] = rule_info("HtmlBlockH3", "HtmlBlockOpenH3 (HtmlBlockH3 | !HtmlBlockCloseH3 .)* HtmlBlockCloseH3") 16159 Rules[:_HtmlBlockOpenH4] = rule_info("HtmlBlockOpenH4", "\"<\" Spnl (\"h4\" | \"H4\") Spnl HtmlAttribute* \">\"") 16160 Rules[:_HtmlBlockCloseH4] = rule_info("HtmlBlockCloseH4", "\"<\" Spnl \"/\" (\"h4\" | \"H4\") Spnl \">\"") 16161 Rules[:_HtmlBlockH4] = rule_info("HtmlBlockH4", "HtmlBlockOpenH4 (HtmlBlockH4 | !HtmlBlockCloseH4 .)* HtmlBlockCloseH4") 16162 Rules[:_HtmlBlockOpenH5] = rule_info("HtmlBlockOpenH5", "\"<\" Spnl (\"h5\" | \"H5\") Spnl HtmlAttribute* \">\"") 16163 Rules[:_HtmlBlockCloseH5] = rule_info("HtmlBlockCloseH5", "\"<\" Spnl \"/\" (\"h5\" | \"H5\") Spnl \">\"") 16164 Rules[:_HtmlBlockH5] = rule_info("HtmlBlockH5", "HtmlBlockOpenH5 (HtmlBlockH5 | !HtmlBlockCloseH5 .)* HtmlBlockCloseH5") 16165 Rules[:_HtmlBlockOpenH6] = rule_info("HtmlBlockOpenH6", "\"<\" Spnl (\"h6\" | \"H6\") Spnl HtmlAttribute* \">\"") 16166 Rules[:_HtmlBlockCloseH6] = rule_info("HtmlBlockCloseH6", "\"<\" Spnl \"/\" (\"h6\" | \"H6\") Spnl \">\"") 16167 Rules[:_HtmlBlockH6] = rule_info("HtmlBlockH6", "HtmlBlockOpenH6 (HtmlBlockH6 | !HtmlBlockCloseH6 .)* HtmlBlockCloseH6") 16168 Rules[:_HtmlBlockOpenMenu] = rule_info("HtmlBlockOpenMenu", "\"<\" Spnl (\"menu\" | \"MENU\") Spnl HtmlAttribute* \">\"") 16169 Rules[:_HtmlBlockCloseMenu] = rule_info("HtmlBlockCloseMenu", "\"<\" Spnl \"/\" (\"menu\" | \"MENU\") Spnl \">\"") 16170 Rules[:_HtmlBlockMenu] = rule_info("HtmlBlockMenu", "HtmlBlockOpenMenu (HtmlBlockMenu | !HtmlBlockCloseMenu .)* HtmlBlockCloseMenu") 16171 Rules[:_HtmlBlockOpenNoframes] = rule_info("HtmlBlockOpenNoframes", "\"<\" Spnl (\"noframes\" | \"NOFRAMES\") Spnl HtmlAttribute* \">\"") 16172 Rules[:_HtmlBlockCloseNoframes] = rule_info("HtmlBlockCloseNoframes", "\"<\" Spnl \"/\" (\"noframes\" | \"NOFRAMES\") Spnl \">\"") 16173 Rules[:_HtmlBlockNoframes] = rule_info("HtmlBlockNoframes", "HtmlBlockOpenNoframes (HtmlBlockNoframes | !HtmlBlockCloseNoframes .)* HtmlBlockCloseNoframes") 16174 Rules[:_HtmlBlockOpenNoscript] = rule_info("HtmlBlockOpenNoscript", "\"<\" Spnl (\"noscript\" | \"NOSCRIPT\") Spnl HtmlAttribute* \">\"") 16175 Rules[:_HtmlBlockCloseNoscript] = rule_info("HtmlBlockCloseNoscript", "\"<\" Spnl \"/\" (\"noscript\" | \"NOSCRIPT\") Spnl \">\"") 16176 Rules[:_HtmlBlockNoscript] = rule_info("HtmlBlockNoscript", "HtmlBlockOpenNoscript (HtmlBlockNoscript | !HtmlBlockCloseNoscript .)* HtmlBlockCloseNoscript") 16177 Rules[:_HtmlBlockOpenOl] = rule_info("HtmlBlockOpenOl", "\"<\" Spnl (\"ol\" | \"OL\") Spnl HtmlAttribute* \">\"") 16178 Rules[:_HtmlBlockCloseOl] = rule_info("HtmlBlockCloseOl", "\"<\" Spnl \"/\" (\"ol\" | \"OL\") Spnl \">\"") 16179 Rules[:_HtmlBlockOl] = rule_info("HtmlBlockOl", "HtmlBlockOpenOl (HtmlBlockOl | !HtmlBlockCloseOl .)* HtmlBlockCloseOl") 16180 Rules[:_HtmlBlockOpenP] = rule_info("HtmlBlockOpenP", "\"<\" Spnl (\"p\" | \"P\") Spnl HtmlAttribute* \">\"") 16181 Rules[:_HtmlBlockCloseP] = rule_info("HtmlBlockCloseP", "\"<\" Spnl \"/\" (\"p\" | \"P\") Spnl \">\"") 16182 Rules[:_HtmlBlockP] = rule_info("HtmlBlockP", "HtmlBlockOpenP (HtmlBlockP | !HtmlBlockCloseP .)* HtmlBlockCloseP") 16183 Rules[:_HtmlBlockOpenPre] = rule_info("HtmlBlockOpenPre", "\"<\" Spnl (\"pre\" | \"PRE\") Spnl HtmlAttribute* \">\"") 16184 Rules[:_HtmlBlockClosePre] = rule_info("HtmlBlockClosePre", "\"<\" Spnl \"/\" (\"pre\" | \"PRE\") Spnl \">\"") 16185 Rules[:_HtmlBlockPre] = rule_info("HtmlBlockPre", "HtmlBlockOpenPre (HtmlBlockPre | !HtmlBlockClosePre .)* HtmlBlockClosePre") 16186 Rules[:_HtmlBlockOpenTable] = rule_info("HtmlBlockOpenTable", "\"<\" Spnl (\"table\" | \"TABLE\") Spnl HtmlAttribute* \">\"") 16187 Rules[:_HtmlBlockCloseTable] = rule_info("HtmlBlockCloseTable", "\"<\" Spnl \"/\" (\"table\" | \"TABLE\") Spnl \">\"") 16188 Rules[:_HtmlBlockTable] = rule_info("HtmlBlockTable", "HtmlBlockOpenTable (HtmlBlockTable | !HtmlBlockCloseTable .)* HtmlBlockCloseTable") 16189 Rules[:_HtmlBlockOpenUl] = rule_info("HtmlBlockOpenUl", "\"<\" Spnl (\"ul\" | \"UL\") Spnl HtmlAttribute* \">\"") 16190 Rules[:_HtmlBlockCloseUl] = rule_info("HtmlBlockCloseUl", "\"<\" Spnl \"/\" (\"ul\" | \"UL\") Spnl \">\"") 16191 Rules[:_HtmlBlockUl] = rule_info("HtmlBlockUl", "HtmlBlockOpenUl (HtmlBlockUl | !HtmlBlockCloseUl .)* HtmlBlockCloseUl") 16192 Rules[:_HtmlBlockOpenDd] = rule_info("HtmlBlockOpenDd", "\"<\" Spnl (\"dd\" | \"DD\") Spnl HtmlAttribute* \">\"") 16193 Rules[:_HtmlBlockCloseDd] = rule_info("HtmlBlockCloseDd", "\"<\" Spnl \"/\" (\"dd\" | \"DD\") Spnl \">\"") 16194 Rules[:_HtmlBlockDd] = rule_info("HtmlBlockDd", "HtmlBlockOpenDd (HtmlBlockDd | !HtmlBlockCloseDd .)* HtmlBlockCloseDd") 16195 Rules[:_HtmlBlockOpenDt] = rule_info("HtmlBlockOpenDt", "\"<\" Spnl (\"dt\" | \"DT\") Spnl HtmlAttribute* \">\"") 16196 Rules[:_HtmlBlockCloseDt] = rule_info("HtmlBlockCloseDt", "\"<\" Spnl \"/\" (\"dt\" | \"DT\") Spnl \">\"") 16197 Rules[:_HtmlBlockDt] = rule_info("HtmlBlockDt", "HtmlBlockOpenDt (HtmlBlockDt | !HtmlBlockCloseDt .)* HtmlBlockCloseDt") 16198 Rules[:_HtmlBlockOpenFrameset] = rule_info("HtmlBlockOpenFrameset", "\"<\" Spnl (\"frameset\" | \"FRAMESET\") Spnl HtmlAttribute* \">\"") 16199 Rules[:_HtmlBlockCloseFrameset] = rule_info("HtmlBlockCloseFrameset", "\"<\" Spnl \"/\" (\"frameset\" | \"FRAMESET\") Spnl \">\"") 16200 Rules[:_HtmlBlockFrameset] = rule_info("HtmlBlockFrameset", "HtmlBlockOpenFrameset (HtmlBlockFrameset | !HtmlBlockCloseFrameset .)* HtmlBlockCloseFrameset") 16201 Rules[:_HtmlBlockOpenLi] = rule_info("HtmlBlockOpenLi", "\"<\" Spnl (\"li\" | \"LI\") Spnl HtmlAttribute* \">\"") 16202 Rules[:_HtmlBlockCloseLi] = rule_info("HtmlBlockCloseLi", "\"<\" Spnl \"/\" (\"li\" | \"LI\") Spnl \">\"") 16203 Rules[:_HtmlBlockLi] = rule_info("HtmlBlockLi", "HtmlBlockOpenLi (HtmlBlockLi | !HtmlBlockCloseLi .)* HtmlBlockCloseLi") 16204 Rules[:_HtmlBlockOpenTbody] = rule_info("HtmlBlockOpenTbody", "\"<\" Spnl (\"tbody\" | \"TBODY\") Spnl HtmlAttribute* \">\"") 16205 Rules[:_HtmlBlockCloseTbody] = rule_info("HtmlBlockCloseTbody", "\"<\" Spnl \"/\" (\"tbody\" | \"TBODY\") Spnl \">\"") 16206 Rules[:_HtmlBlockTbody] = rule_info("HtmlBlockTbody", "HtmlBlockOpenTbody (HtmlBlockTbody | !HtmlBlockCloseTbody .)* HtmlBlockCloseTbody") 16207 Rules[:_HtmlBlockOpenTd] = rule_info("HtmlBlockOpenTd", "\"<\" Spnl (\"td\" | \"TD\") Spnl HtmlAttribute* \">\"") 16208 Rules[:_HtmlBlockCloseTd] = rule_info("HtmlBlockCloseTd", "\"<\" Spnl \"/\" (\"td\" | \"TD\") Spnl \">\"") 16209 Rules[:_HtmlBlockTd] = rule_info("HtmlBlockTd", "HtmlBlockOpenTd (HtmlBlockTd | !HtmlBlockCloseTd .)* HtmlBlockCloseTd") 16210 Rules[:_HtmlBlockOpenTfoot] = rule_info("HtmlBlockOpenTfoot", "\"<\" Spnl (\"tfoot\" | \"TFOOT\") Spnl HtmlAttribute* \">\"") 16211 Rules[:_HtmlBlockCloseTfoot] = rule_info("HtmlBlockCloseTfoot", "\"<\" Spnl \"/\" (\"tfoot\" | \"TFOOT\") Spnl \">\"") 16212 Rules[:_HtmlBlockTfoot] = rule_info("HtmlBlockTfoot", "HtmlBlockOpenTfoot (HtmlBlockTfoot | !HtmlBlockCloseTfoot .)* HtmlBlockCloseTfoot") 16213 Rules[:_HtmlBlockOpenTh] = rule_info("HtmlBlockOpenTh", "\"<\" Spnl (\"th\" | \"TH\") Spnl HtmlAttribute* \">\"") 16214 Rules[:_HtmlBlockCloseTh] = rule_info("HtmlBlockCloseTh", "\"<\" Spnl \"/\" (\"th\" | \"TH\") Spnl \">\"") 16215 Rules[:_HtmlBlockTh] = rule_info("HtmlBlockTh", "HtmlBlockOpenTh (HtmlBlockTh | !HtmlBlockCloseTh .)* HtmlBlockCloseTh") 16216 Rules[:_HtmlBlockOpenThead] = rule_info("HtmlBlockOpenThead", "\"<\" Spnl (\"thead\" | \"THEAD\") Spnl HtmlAttribute* \">\"") 16217 Rules[:_HtmlBlockCloseThead] = rule_info("HtmlBlockCloseThead", "\"<\" Spnl \"/\" (\"thead\" | \"THEAD\") Spnl \">\"") 16218 Rules[:_HtmlBlockThead] = rule_info("HtmlBlockThead", "HtmlBlockOpenThead (HtmlBlockThead | !HtmlBlockCloseThead .)* HtmlBlockCloseThead") 16219 Rules[:_HtmlBlockOpenTr] = rule_info("HtmlBlockOpenTr", "\"<\" Spnl (\"tr\" | \"TR\") Spnl HtmlAttribute* \">\"") 16220 Rules[:_HtmlBlockCloseTr] = rule_info("HtmlBlockCloseTr", "\"<\" Spnl \"/\" (\"tr\" | \"TR\") Spnl \">\"") 16221 Rules[:_HtmlBlockTr] = rule_info("HtmlBlockTr", "HtmlBlockOpenTr (HtmlBlockTr | !HtmlBlockCloseTr .)* HtmlBlockCloseTr") 16222 Rules[:_HtmlBlockOpenScript] = rule_info("HtmlBlockOpenScript", "\"<\" Spnl (\"script\" | \"SCRIPT\") Spnl HtmlAttribute* \">\"") 16223 Rules[:_HtmlBlockCloseScript] = rule_info("HtmlBlockCloseScript", "\"<\" Spnl \"/\" (\"script\" | \"SCRIPT\") Spnl \">\"") 16224 Rules[:_HtmlBlockScript] = rule_info("HtmlBlockScript", "HtmlBlockOpenScript (!HtmlBlockCloseScript .)* HtmlBlockCloseScript") 16225 Rules[:_HtmlBlockInTags] = rule_info("HtmlBlockInTags", "(HtmlBlockAddress | HtmlBlockBlockquote | HtmlBlockCenter | HtmlBlockDir | HtmlBlockDiv | HtmlBlockDl | HtmlBlockFieldset | HtmlBlockForm | HtmlBlockH1 | HtmlBlockH2 | HtmlBlockH3 | HtmlBlockH4 | HtmlBlockH5 | HtmlBlockH6 | HtmlBlockMenu | HtmlBlockNoframes | HtmlBlockNoscript | HtmlBlockOl | HtmlBlockP | HtmlBlockPre | HtmlBlockTable | HtmlBlockUl | HtmlBlockDd | HtmlBlockDt | HtmlBlockFrameset | HtmlBlockLi | HtmlBlockTbody | HtmlBlockTd | HtmlBlockTfoot | HtmlBlockTh | HtmlBlockThead | HtmlBlockTr | HtmlBlockScript)") 16226 Rules[:_HtmlBlock] = rule_info("HtmlBlock", "< (HtmlBlockInTags | HtmlComment | HtmlBlockSelfClosing | HtmlUnclosed) > BlankLine+ { if html? then RDoc::Markup::Raw.new text end }") 16227 Rules[:_HtmlUnclosed] = rule_info("HtmlUnclosed", "\"<\" Spnl HtmlUnclosedType Spnl HtmlAttribute* Spnl \">\"") 16228 Rules[:_HtmlUnclosedType] = rule_info("HtmlUnclosedType", "(\"HR\" | \"hr\")") 16229 Rules[:_HtmlBlockSelfClosing] = rule_info("HtmlBlockSelfClosing", "\"<\" Spnl HtmlBlockType Spnl HtmlAttribute* \"/\" Spnl \">\"") 16230 Rules[:_HtmlBlockType] = rule_info("HtmlBlockType", "(\"ADDRESS\" | \"BLOCKQUOTE\" | \"CENTER\" | \"DD\" | \"DIR\" | \"DIV\" | \"DL\" | \"DT\" | \"FIELDSET\" | \"FORM\" | \"FRAMESET\" | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\" | \"HR\" | \"ISINDEX\" | \"LI\" | \"MENU\" | \"NOFRAMES\" | \"NOSCRIPT\" | \"OL\" | \"P\" | \"PRE\" | \"SCRIPT\" | \"TABLE\" | \"TBODY\" | \"TD\" | \"TFOOT\" | \"TH\" | \"THEAD\" | \"TR\" | \"UL\" | \"address\" | \"blockquote\" | \"center\" | \"dd\" | \"dir\" | \"div\" | \"dl\" | \"dt\" | \"fieldset\" | \"form\" | \"frameset\" | \"h1\" | \"h2\" | \"h3\" | \"h4\" | \"h5\" | \"h6\" | \"hr\" | \"isindex\" | \"li\" | \"menu\" | \"noframes\" | \"noscript\" | \"ol\" | \"p\" | \"pre\" | \"script\" | \"table\" | \"tbody\" | \"td\" | \"tfoot\" | \"th\" | \"thead\" | \"tr\" | \"ul\")") 16231 Rules[:_StyleOpen] = rule_info("StyleOpen", "\"<\" Spnl (\"style\" | \"STYLE\") Spnl HtmlAttribute* \">\"") 16232 Rules[:_StyleClose] = rule_info("StyleClose", "\"<\" Spnl \"/\" (\"style\" | \"STYLE\") Spnl \">\"") 16233 Rules[:_InStyleTags] = rule_info("InStyleTags", "StyleOpen (!StyleClose .)* StyleClose") 16234 Rules[:_StyleBlock] = rule_info("StyleBlock", "< InStyleTags > BlankLine* { if css? then RDoc::Markup::Raw.new text end }") 16235 Rules[:_Inlines] = rule_info("Inlines", "(!Endline Inline:i { i } | Endline:c &Inline { c })+:chunks Endline? { chunks }") 16236 Rules[:_Inline] = rule_info("Inline", "(Str | Endline | UlOrStarLine | Space | Strong | Emph | Image | Link | NoteReference | InlineNote | Code | RawHtml | Entity | EscapedChar | Symbol)") 16237 Rules[:_Space] = rule_info("Space", "Spacechar+ { \" \" }") 16238 Rules[:_Str] = rule_info("Str", "StartList:a < NormalChar+ > { a = text } (StrChunk:c { a << c })* { a }") 16239 Rules[:_StrChunk] = rule_info("StrChunk", "< (NormalChar | \"_\"+ &Alphanumeric)+ > { text }") 16240 Rules[:_EscapedChar] = rule_info("EscapedChar", "\"\\\\\" !Newline < /[:\\\\`|*_{}\\[\\]()\#+.!><-]/ > { text }") 16241 Rules[:_Entity] = rule_info("Entity", "(HexEntity | DecEntity | CharEntity):a { a }") 16242 Rules[:_Endline] = rule_info("Endline", "(LineBreak | TerminalEndline | NormalEndline)") 16243 Rules[:_NormalEndline] = rule_info("NormalEndline", "Sp Newline !BlankLine !\">\" !AtxStart !(Line (\"===\" \"=\"* | \"---\" \"-\"*) Newline) { \"\\n\" }") 16244 Rules[:_TerminalEndline] = rule_info("TerminalEndline", "Sp Newline Eof") 16245 Rules[:_LineBreak] = rule_info("LineBreak", "\" \" NormalEndline { RDoc::Markup::HardBreak.new }") 16246 Rules[:_Symbol] = rule_info("Symbol", "< SpecialChar > { text }") 16247 Rules[:_UlOrStarLine] = rule_info("UlOrStarLine", "(UlLine | StarLine):a { a }") 16248 Rules[:_StarLine] = rule_info("StarLine", "(< \"****\" \"*\"* > { text } | < Spacechar \"*\"+ &Spacechar > { text })") 16249 Rules[:_UlLine] = rule_info("UlLine", "(< \"____\" \"_\"* > { text } | < Spacechar \"_\"+ &Spacechar > { text })") 16250 Rules[:_Emph] = rule_info("Emph", "(EmphStar | EmphUl)") 16251 Rules[:_OneStarOpen] = rule_info("OneStarOpen", "!StarLine \"*\" !Spacechar !Newline") 16252 Rules[:_OneStarClose] = rule_info("OneStarClose", "!Spacechar !Newline Inline:a \"*\" { a }") 16253 Rules[:_EmphStar] = rule_info("EmphStar", "OneStarOpen StartList:a (!OneStarClose Inline:l { a << l })* OneStarClose:l { a << l } { emphasis a.join }") 16254 Rules[:_OneUlOpen] = rule_info("OneUlOpen", "!UlLine \"_\" !Spacechar !Newline") 16255 Rules[:_OneUlClose] = rule_info("OneUlClose", "!Spacechar !Newline Inline:a \"_\" { a }") 16256 Rules[:_EmphUl] = rule_info("EmphUl", "OneUlOpen StartList:a (!OneUlClose Inline:l { a << l })* OneUlClose:l { a << l } { emphasis a.join }") 16257 Rules[:_Strong] = rule_info("Strong", "(StrongStar | StrongUl)") 16258 Rules[:_TwoStarOpen] = rule_info("TwoStarOpen", "!StarLine \"**\" !Spacechar !Newline") 16259 Rules[:_TwoStarClose] = rule_info("TwoStarClose", "!Spacechar !Newline Inline:a \"**\" { a }") 16260 Rules[:_StrongStar] = rule_info("StrongStar", "TwoStarOpen StartList:a (!TwoStarClose Inline:l { a << l })* TwoStarClose:l { a << l } { strong a.join }") 16261 Rules[:_TwoUlOpen] = rule_info("TwoUlOpen", "!UlLine \"__\" !Spacechar !Newline") 16262 Rules[:_TwoUlClose] = rule_info("TwoUlClose", "!Spacechar !Newline Inline:a \"__\" { a }") 16263 Rules[:_StrongUl] = rule_info("StrongUl", "TwoUlOpen StartList:a (!TwoUlClose Inline:i { a << i })* TwoUlClose:l { a << l } { strong a.join }") 16264 Rules[:_Image] = rule_info("Image", "\"!\" (ExplicitLink | ReferenceLink):a { a }") 16265 Rules[:_Link] = rule_info("Link", "(ExplicitLink | ReferenceLink | AutoLink)") 16266 Rules[:_ReferenceLink] = rule_info("ReferenceLink", "(ReferenceLinkDouble | ReferenceLinkSingle)") 16267 Rules[:_ReferenceLinkDouble] = rule_info("ReferenceLinkDouble", "Label:content < Spnl > !\"[]\" Label:label { link_to content, label, text }") 16268 Rules[:_ReferenceLinkSingle] = rule_info("ReferenceLinkSingle", "Label:content < (Spnl \"[]\")? > { link_to content, content, text }") 16269 Rules[:_ExplicitLink] = rule_info("ExplicitLink", "Label:l Spnl \"(\" Sp Source:s Spnl Title Sp \")\" { \"{\#{l}}[\#{s}]\" }") 16270 Rules[:_Source] = rule_info("Source", "(\"<\" < SourceContents > \">\" | < SourceContents >) { text }") 16271 Rules[:_SourceContents] = rule_info("SourceContents", "(((!\"(\" !\")\" !\">\" Nonspacechar)+ | \"(\" SourceContents \")\")* | \"\")") 16272 Rules[:_Title] = rule_info("Title", "(TitleSingle | TitleDouble | \"\"):a { a }") 16273 Rules[:_TitleSingle] = rule_info("TitleSingle", "\"'\" (!(\"'\" Sp (\")\" | Newline)) .)* \"'\"") 16274 Rules[:_TitleDouble] = rule_info("TitleDouble", "\"\\\"\" (!(\"\\\"\" Sp (\")\" | Newline)) .)* \"\\\"\"") 16275 Rules[:_AutoLink] = rule_info("AutoLink", "(AutoLinkUrl | AutoLinkEmail)") 16276 Rules[:_AutoLinkUrl] = rule_info("AutoLinkUrl", "\"<\" < /[A-Za-z]+/ \"://\" (!Newline !\">\" .)+ > \">\" { text }") 16277 Rules[:_AutoLinkEmail] = rule_info("AutoLinkEmail", "\"<\" \"mailto:\"? < /[\\w+.\\/!%~$-]+/i \"@\" (!Newline !\">\" .)+ > \">\" { \"mailto:\#{text}\" }") 16278 Rules[:_Reference] = rule_info("Reference", "NonindentSpace !\"[]\" Label:label \":\" Spnl RefSrc:link RefTitle BlankLine+ { \# TODO use title reference label, link nil }") 16279 Rules[:_Label] = rule_info("Label", "\"[\" (!\"^\" &{ notes? } | &. &{ !notes? }) StartList:a (!\"]\" Inline:l { a << l })* \"]\" { a.join.gsub(/\\s+/, ' ') }") 16280 Rules[:_RefSrc] = rule_info("RefSrc", "< Nonspacechar+ > { text }") 16281 Rules[:_RefTitle] = rule_info("RefTitle", "(RefTitleSingle | RefTitleDouble | RefTitleParens | EmptyTitle)") 16282 Rules[:_EmptyTitle] = rule_info("EmptyTitle", "\"\"") 16283 Rules[:_RefTitleSingle] = rule_info("RefTitleSingle", "Spnl \"'\" < (!(\"'\" Sp Newline | Newline) .)* > \"'\" { text }") 16284 Rules[:_RefTitleDouble] = rule_info("RefTitleDouble", "Spnl \"\\\"\" < (!(\"\\\"\" Sp Newline | Newline) .)* > \"\\\"\" { text }") 16285 Rules[:_RefTitleParens] = rule_info("RefTitleParens", "Spnl \"(\" < (!(\")\" Sp Newline | Newline) .)* > \")\" { text }") 16286 Rules[:_References] = rule_info("References", "(Reference | SkipBlock)*") 16287 Rules[:_Ticks1] = rule_info("Ticks1", "\"`\" !\"`\"") 16288 Rules[:_Ticks2] = rule_info("Ticks2", "\"``\" !\"`\"") 16289 Rules[:_Ticks3] = rule_info("Ticks3", "\"```\" !\"`\"") 16290 Rules[:_Ticks4] = rule_info("Ticks4", "\"````\" !\"`\"") 16291 Rules[:_Ticks5] = rule_info("Ticks5", "\"`````\" !\"`\"") 16292 Rules[:_Code] = rule_info("Code", "(Ticks1 Sp < ((!\"`\" Nonspacechar)+ | !Ticks1 \"`\"+ | !(Sp Ticks1) (Spacechar | Newline !BlankLine))+ > Sp Ticks1 | Ticks2 Sp < ((!\"`\" Nonspacechar)+ | !Ticks2 \"`\"+ | !(Sp Ticks2) (Spacechar | Newline !BlankLine))+ > Sp Ticks2 | Ticks3 Sp < ((!\"`\" Nonspacechar)+ | !Ticks3 \"`\"+ | !(Sp Ticks3) (Spacechar | Newline !BlankLine))+ > Sp Ticks3 | Ticks4 Sp < ((!\"`\" Nonspacechar)+ | !Ticks4 \"`\"+ | !(Sp Ticks4) (Spacechar | Newline !BlankLine))+ > Sp Ticks4 | Ticks5 Sp < ((!\"`\" Nonspacechar)+ | !Ticks5 \"`\"+ | !(Sp Ticks5) (Spacechar | Newline !BlankLine))+ > Sp Ticks5) { \"<code>\#{text}</code>\" }") 16293 Rules[:_RawHtml] = rule_info("RawHtml", "< (HtmlComment | HtmlBlockScript | HtmlTag) > { if html? then text else '' end }") 16294 Rules[:_BlankLine] = rule_info("BlankLine", "Sp Newline { \"\\n\" }") 16295 Rules[:_Quoted] = rule_info("Quoted", "(\"\\\"\" (!\"\\\"\" .)* \"\\\"\" | \"'\" (!\"'\" .)* \"'\")") 16296 Rules[:_HtmlAttribute] = rule_info("HtmlAttribute", "(AlphanumericAscii | \"-\")+ Spnl (\"=\" Spnl (Quoted | (!\">\" Nonspacechar)+))? Spnl") 16297 Rules[:_HtmlComment] = rule_info("HtmlComment", "\"<!--\" (!\"-->\" .)* \"-->\"") 16298 Rules[:_HtmlTag] = rule_info("HtmlTag", "\"<\" Spnl \"/\"? AlphanumericAscii+ Spnl HtmlAttribute* \"/\"? Spnl \">\"") 16299 Rules[:_Eof] = rule_info("Eof", "!.") 16300 Rules[:_Nonspacechar] = rule_info("Nonspacechar", "!Spacechar !Newline .") 16301 Rules[:_Sp] = rule_info("Sp", "Spacechar*") 16302 Rules[:_Spnl] = rule_info("Spnl", "Sp (Newline Sp)?") 16303 Rules[:_SpecialChar] = rule_info("SpecialChar", "(\"*\" | \"_\" | \"`\" | \"&\" | \"[\" | \"]\" | \"(\" | \")\" | \"<\" | \"!\" | \"\#\" | \"\\\\\" | \"'\" | \"\\\"\" | ExtendedSpecialChar)") 16304 Rules[:_NormalChar] = rule_info("NormalChar", "!(SpecialChar | Spacechar | Newline) .") 16305 Rules[:_Digit] = rule_info("Digit", "[0-9]") 16306 Rules[:_Alphanumeric] = rule_info("Alphanumeric", "%literals.Alphanumeric") 16307 Rules[:_AlphanumericAscii] = rule_info("AlphanumericAscii", "%literals.AlphanumericAscii") 16308 Rules[:_BOM] = rule_info("BOM", "%literals.BOM") 16309 Rules[:_Newline] = rule_info("Newline", "%literals.Newline") 16310 Rules[:_NonAlphanumeric] = rule_info("NonAlphanumeric", "%literals.NonAlphanumeric") 16311 Rules[:_Spacechar] = rule_info("Spacechar", "%literals.Spacechar") 16312 Rules[:_HexEntity] = rule_info("HexEntity", "\"&\" \"\#\" /[Xx]/ < /[0-9a-fA-F]+/ > \";\" { [text.to_i(16)].pack 'U' }") 16313 Rules[:_DecEntity] = rule_info("DecEntity", "\"&\" \"\#\" < /[0-9]+/ > \";\" { [text.to_i].pack 'U' }") 16314 Rules[:_CharEntity] = rule_info("CharEntity", "\"&\" < /[A-Za-z0-9]+/ > \";\" { if entity = HTML_ENTITIES[text] then entity.pack 'U*' else \"&\#{text};\" end }") 16315 Rules[:_NonindentSpace] = rule_info("NonindentSpace", "(\" \" | \" \" | \" \" | \"\")") 16316 Rules[:_Indent] = rule_info("Indent", "(\"\\t\" | \" \")") 16317 Rules[:_IndentedLine] = rule_info("IndentedLine", "Indent Line") 16318 Rules[:_OptionallyIndentedLine] = rule_info("OptionallyIndentedLine", "Indent? Line") 16319 Rules[:_StartList] = rule_info("StartList", "&. { [] }") 16320 Rules[:_Line] = rule_info("Line", "RawLine:a { a }") 16321 Rules[:_RawLine] = rule_info("RawLine", "(< (!\"\r\" !\"\\n\" .)* Newline > | < .+ > Eof) { text }") 16322 Rules[:_SkipBlock] = rule_info("SkipBlock", "(HtmlBlock | (!\"\#\" !SetextBottom1 !SetextBottom2 !BlankLine RawLine)+ BlankLine* | BlankLine+ | RawLine)") 16323 Rules[:_ExtendedSpecialChar] = rule_info("ExtendedSpecialChar", "&{ notes? } \"^\"") 16324 Rules[:_NoteReference] = rule_info("NoteReference", "&{ notes? } RawNoteReference:ref { note_for ref }") 16325 Rules[:_RawNoteReference] = rule_info("RawNoteReference", "\"[^\" < (!Newline !\"]\" .)+ > \"]\" { text }") 16326 Rules[:_Note] = rule_info("Note", "&{ notes? } NonindentSpace RawNoteReference:ref \":\" Sp StartList:a RawNoteBlock (&Indent RawNoteBlock:i { a.concat i })* { @footnotes[ref] = paragraph a nil }") 16327 Rules[:_InlineNote] = rule_info("InlineNote", "&{ notes? } \"^[\" StartList:a (!\"]\" Inline:l { a << l })+ \"]\" { ref = [:inline, @note_order.length] @footnotes[ref] = paragraph a note_for ref }") 16328 Rules[:_Notes] = rule_info("Notes", "(Note | SkipBlock)*") 16329 Rules[:_RawNoteBlock] = rule_info("RawNoteBlock", "StartList:a (!BlankLine OptionallyIndentedLine:l { a << l })+ < BlankLine* > { a << text } { a }") 16330 Rules[:_CodeFence] = rule_info("CodeFence", "&{ github? } Ticks3 (Sp StrChunk:format)? Spnl < ((!\"`\" Nonspacechar)+ | !Ticks3 \"`\"+ | Spacechar | Newline)+ > Ticks3 Sp Newline* { verbatim = RDoc::Markup::Verbatim.new text verbatim.format = format.intern if format verbatim }") 16331 Rules[:_DefinitionList] = rule_info("DefinitionList", "&{ definition_lists? } DefinitionListItem+:list { RDoc::Markup::List.new :NOTE, *list.flatten }") 16332 Rules[:_DefinitionListItem] = rule_info("DefinitionListItem", "DefinitionListLabel+:label DefinitionListDefinition+:defns { list_items = [] list_items << RDoc::Markup::ListItem.new(label, defns.shift) list_items.concat defns.map { |defn| RDoc::Markup::ListItem.new nil, defn } unless list_items.empty? list_items }") 16333 Rules[:_DefinitionListLabel] = rule_info("DefinitionListLabel", "StrChunk:label Sp Newline { label }") 16334 Rules[:_DefinitionListDefinition] = rule_info("DefinitionListDefinition", "NonindentSpace \":\" Space Inlines:a BlankLine+ { paragraph a }") 16335 # :startdoc: 16336end 16337