review-peg 0.1.0

data/lib/review/review.kpeg

@@ -0,0 +1,745 @@
+%% name = ReVIEW::Compiler
+
+%% {
+  class Error; end
+  class Position
+    attr_accessor :pos, :line, :col
+    def initialize(compiler)
+      @pos = compiler.pos
+      @line = compiler.current_line
+      @col = compiler.current_column
+    end
+  end
+
+# rubocop:disable all
+require 'review/location'
+require 'review/extentions'
+require 'review/preprocessor'
+require 'review/exception'
+require 'review/node'
+  require 'lineinput'
+  require 'review/compiler/literals_1_9'
+  # require 'review/compiler/literals_1_8'
+
+  ## redifine Compiler.new
+  def initialize(strategy)
+    @strategy = strategy
+    @current_column = nil
+    @chapter = nil
+  end
+
+  attr_accessor :strategy
+
+    def compile(chap)
+      @chapter = chap
+      do_compile
+      @strategy.result
+    end
+
+    def do_compile
+      @strategy.bind self, @chapter, ReVIEW::Location.new(@chapter.basename, self)
+      setup_parser(@chapter.content)
+      parse()
+      convert_ast
+    end
+
+    def convert_ast
+      ast = @strategy.ast
+      convert_column(ast)
+      if $DEBUG
+        File.open("review-dump.json","w") do |f|
+          f.write(ast.to_json)
+        end
+      end
+      @strategy.output << ast.to_doc
+    end
+
+    def flush_column(new_content)
+      if @current_column
+        new_content << @current_column
+        @current_column = nil
+      end
+    end
+
+    def convert_column(ast)
+      @column_stack = []
+      content = ast.content
+      new_content = []
+      @current_content = new_content
+      content.each do |elem|
+        if elem.kind_of?(ReVIEW::HeadlineNode) && elem.cmd && elem.cmd.to_doc == "column"
+          flush_column(new_content)
+          @current_content = []
+          @current_column = ReVIEW::ColumnNode.new(elem.compiler, elem.position, elem.level,
+                                                  elem.label, elem.content, @current_content)
+          next
+        elsif elem.kind_of?(ReVIEW::HeadlineNode) && elem.cmd && elem.cmd.to_doc =~ %r|^/|
+          cmd_name = elem.cmd.to_doc[1..-1]
+          if cmd_name != "column"
+            raise ReVIEW::CompileError, "#{cmd_name} is not opened."
+          end
+          flush_column(new_content)
+          @current_content = new_content
+          next
+        elsif elem.kind_of?(ReVIEW::HeadlineNode) && @current_column && elem.level <= @current_column.level
+          flush_column(new_content)
+          @current_content = new_content
+        end
+        @current_content << elem
+      end
+      flush_column(new_content)
+      ast.content = new_content
+      ast
+    end
+
+    def compile_text(text)
+      @strategy.nofunc_text(text)
+    end
+
+    class SyntaxElement
+      def initialize(name, type, argc, esc, &block)
+        @name = name
+        @type = type
+        @argc_spec = argc
+        @esc_patterns = esc
+        @checker = block
+      end
+
+      attr_reader :name
+
+      def check_args(args)
+        unless @argc_spec === args.size
+          raise ReVIEW::CompileError, "wrong # of parameters (block command //#{@name}, expect #{@argc_spec} but #{args.size})"
+        end
+        @checker.call(*args) if @checker
+      end
+
+      def min_argc
+        case @argc_spec
+        when Range then @argc_spec.begin
+        when Integer then @argc_spec
+        else
+          raise TypeError, "argc_spec is not Range/Integer: #{inspect()}"
+        end
+      end
+
+      def parse_args(args)
+        if @esc_patterns
+          args.map.with_index do |pattern, i|
+            if @esc_patterns[i]
+              args[i].__send__("to_#{@esc_patterns[i]}")
+            else
+              args[i].to_doc
+            end
+          end
+        else
+          args.map(&:to_doc)
+        end
+      end
+
+      def block_required?
+        @type == :block or @type == :code_block
+      end
+
+      def block_allowed?
+        @type == :block or @type == :code_block or @type == :optional or @type == :optional_code_block
+      end
+
+      def code_block?
+        @type == :code_block or @type == :optional_code_block
+      end
+    end
+
+    SYNTAX = {}
+
+    def self.defblock(name, argc, optional = false, esc = nil, &block)
+      defsyntax(name, (optional ? :optional : :block), argc, esc, &block)
+    end
+
+    def self.defcodeblock(name, argc, optional = false, esc = nil, &block)
+      defsyntax(name, (optional ? :optional_code_block : :code_block), argc, esc, &block)
+    end
+
+    def self.defsingle(name, argc, esc = nil, &block)
+      defsyntax name, :line, argc, esc, &block
+    end
+
+    def self.defsyntax(name, type, argc, esc = nil, &block)
+      SYNTAX[name] = SyntaxElement.new(name, type, argc, esc, &block)
+    end
+
+    def syntax_defined?(name)
+      SYNTAX.key?(name.to_sym)
+    end
+
+    def syntax_descriptor(name)
+      SYNTAX[name.to_sym]
+    end
+
+    class InlineSyntaxElement
+      def initialize(name)
+        @name = name
+      end
+
+      attr_reader :name
+    end
+
+    INLINE = {}
+    COMPLEX_INLINE = {}
+
+    def self.definline(name)
+      INLINE[name] = InlineSyntaxElement.new(name)
+    end
+
+    def self.defcomplexinline(name)
+      COMPLEX_INLINE[name] = InlineSyntaxElement.new(name)
+    end
+
+    def inline_defined?(name)
+      INLINE.key?(name.to_sym) || COMPLEX_INLINE.key?(name.to_sym)
+    end
+
+    defblock :read, 0
+    defblock :lead, 0
+    defblock :quote, 0
+    defblock :bibpaper, 2..3, true, [:raw, :doc, :doc]
+    defblock :doorquote, 1, false, [:doc]
+    defblock :talk, 0
+    defblock :graph, 1..3, false, [:raw, :raw, :doc]
+
+    defcodeblock :emlist, 0..2, false, [:doc, :raw]
+    defcodeblock :cmd, 0..1, false, [:doc]
+    defcodeblock :source, 0..2, false, [:doc, :raw]
+    defcodeblock :list, 2..4, false, [:raw, :doc, :raw, :raw]
+    defcodeblock :listnum, 2..3, false, [:raw, :doc, :raw]
+    defcodeblock :emlistnum, 0..2, false, [:doc, :raw]
+    defcodeblock :texequation, 0, false
+    defcodeblock :table, 0..2, false, [:raw, :doc]
+    defcodeblock :image, 2..3, true, [:raw,:doc,:raw]
+    defcodeblock :box, 0..1, false, [:doc]
+
+    defblock :address, 0
+    defblock :blockquote, 0
+    defblock :bpo, 0
+    defblock :flushright, 0
+    defblock :centering, 0
+    defblock :note, 0..1
+    defblock :comment, 0..1, true
+
+    defsingle :footnote, 2, [:raw, :doc]
+    defsingle :noindent, 0
+    defsingle :linebreak, 0
+    defsingle :pagebreak, 0
+    defsingle :indepimage, 1..3, [:raw, :doc, :raw]
+    defsingle :numberlessimage, 1..3, [:raw, :doc, :raw]
+    defsingle :hr, 0
+    defsingle :parasep, 0
+    defsingle :label, 1, [:raw]
+    defsingle :raw, 1, [:raw]
+    defsingle :tsize, 1, [:raw]
+    defsingle :include, 1, [:raw]
+    defsingle :olnum, 1, [:raw]
+
+    definline :chapref
+    definline :chap
+    definline :title
+    definline :img
+    definline :imgref
+    definline :icon
+    definline :list
+    definline :table
+    definline :fn
+    definline :bou
+    definline :ami
+    definline :b
+    definline :dtp
+    definline :code
+    definline :bib
+    definline :hd
+    definline :recipe
+    definline :column
+
+    definline :abbr
+    definline :acronym
+    definline :cite
+    definline :dfn
+    definline :em
+    definline :kbd
+    definline :q
+    definline :samp
+    definline :strong
+    definline :var
+    definline :big
+    definline :small
+    definline :del
+    definline :ins
+    definline :sup
+    definline :sub
+    definline :tt
+    definline :i
+    definline :tti
+    definline :ttb
+    definline :u
+    definline :raw
+    definline :br
+    definline :m
+    definline :uchar
+    definline :idx
+    definline :hidx
+    definline :comment
+    definline :include
+
+    defcomplexinline :kw
+    defcomplexinline :ruby
+    defcomplexinline :href
+
+    def compile_column(level, label, caption, content)
+      buf = ""
+      buf << @strategy.__send__("column_begin", level, label, caption)
+      buf << content.to_doc
+      buf << @strategy.__send__("column_end", level)
+      buf
+    end
+
+    def compile_command(name, args, lines, node)
+      syntax = syntax_descriptor(name)
+      if !syntax || (!@strategy.respond_to?(syntax.name) && !@strategy.respond_to?("node_#{syntax.name}"))
+        error "strategy does not support command: //#{name}"
+        compile_unknown_command args, lines
+        return
+      end
+      begin
+        syntax.check_args args
+      rescue ReVIEW::CompileError => err
+        error err.message
+        args = ['(NoArgument)'] * syntax.min_argc
+      end
+      if syntax.block_allowed?
+        compile_block(syntax, args, lines, node)
+      else
+        if lines
+          error "block is not allowed for command //#{syntax.name}; ignore"
+        end
+        compile_single(syntax, args, node)
+      end
+    end
+
+    def compile_headline(level, tag, label, caption)
+      buf = ""
+      @headline_indexs ||= [0] ## XXX
+      caption ||= ""
+      caption.strip!
+      index = level - 1
+      if @headline_indexs.size > (index + 1)
+        @headline_indexs = @headline_indexs[0..index]
+      end
+      @headline_indexs[index] = 0 if @headline_indexs[index].nil?
+      @headline_indexs[index] += 1
+      buf << @strategy.headline(level, label, caption)
+      buf
+    end
+
+    def comment(text)
+      @strategy.comment(text)
+    end
+
+    def compile_ulist(content)
+      buf0 = ""
+      level = 0
+      content.each do |element|
+        current_level = element.level
+        buf = element.to_doc
+        if level == current_level
+          buf0 << @strategy.ul_item_end
+          # body
+          buf0 << @strategy.ul_item_begin([buf])
+        elsif level < current_level # down
+          level_diff = current_level - level
+          level = current_level
+          (1..(level_diff - 1)).to_a.reverse_each do |i|
+            buf0 << @strategy.ul_begin{i}
+            buf0 << @strategy.ul_item_begin([])
+          end
+          buf0 << @strategy.ul_begin{level}
+          buf0 << @strategy.ul_item_begin([buf])
+        elsif level > current_level # up
+          level_diff = level - current_level
+          level = current_level
+          (1..level_diff).to_a.reverse_each do |i|
+            buf0 << @strategy.ul_item_end
+            buf0 << @strategy.ul_end{level + i}
+          end
+          buf0 << @strategy.ul_item_end
+          # body
+          buf0 <<@strategy.ul_item_begin([buf])
+        end
+      end
+
+      (1..level).to_a.reverse_each do |i|
+        buf0 << @strategy.ul_item_end
+        buf0 << @strategy.ul_end{i}
+      end
+      buf0
+    end
+
+    def compile_olist(content)
+      buf0 = ""
+      buf0 << @strategy.ol_begin
+      content.each do |element|
+        ## XXX 1st arg should be String, not Array
+        buf0 << @strategy.ol_item(element.to_doc.split(/\n/), element.num)
+      end
+      buf0 << @strategy.ol_end
+      buf0
+    end
+
+    def compile_dlist(content)
+      buf = ""
+      buf << @strategy.dl_begin
+      content.each do |element|
+        buf << @strategy.dt(element.text.to_doc)
+        buf << @strategy.dd(element.content.map{|s| s.to_doc})
+      end
+      buf << @strategy.dl_end
+      buf
+    end
+
+
+    def compile_unknown_command(args, lines)
+      @strategy.unknown_command(args, lines)
+    end
+
+    def compile_block(syntax, args, lines, node)
+      node_name = "node_#{syntax.name}".to_sym
+      if @strategy.respond_to?(node_name)
+        @strategy.__send__(node_name, node)
+      else
+        args_conv = syntax.parse_args(args)
+        @strategy.__send__(syntax.name, (lines || default_block(syntax)), *args_conv)
+      end
+    end
+
+    def default_block(syntax)
+      if syntax.block_required?
+        error "block is required for //#{syntax.name}; use empty block"
+      end
+      []
+    end
+
+    def compile_single(syntax, args, node)
+      node_name = "node_#{syntax.name}".to_sym
+      if @strategy.respond_to?(node_name)
+        @strategy.__send__(node_name, node)
+      else
+        args_conv = syntax.parse_args(args)
+        @strategy.__send__(syntax.name, *args_conv)
+      end
+    end
+
+
+    def compile_inline(op, args)
+      unless inline_defined?(op)
+        raise ReVIEW::CompileError, "no such inline op: #{op}"
+      end
+      if @strategy.respond_to?("node_inline_#{op}")
+        return @strategy.__send__("node_inline_#{op}", args)
+      end
+      unless @strategy.respond_to?("inline_#{op}")
+        raise "strategy does not support inline op: @<#{op}>"
+      end
+      if !args
+        @strategy.__send__("inline_#{op}", "")
+      else
+        @strategy.__send__("inline_#{op}", *(args.map(&:to_doc)))
+      end
+#    rescue => err
+#      error err.message
+    end
+
+    def compile_paragraph(buf)
+      @strategy.paragraph buf
+    end
+
+    def compile_raw(builders, content)
+      c = @strategy.class.to_s.gsub(/ReVIEW::/, '').gsub(/Builder/, '').downcase
+      if !builders || builders.include?(c)
+        content.gsub("\\n", "\n")
+      else
+        ""
+      end
+    end
+
+    def warn(msg)
+      @strategy.warn msg
+    end
+
+    def error(msg)
+      @strategy.error msg
+    end
+
+    def check_indent(s)
+      s.size >= @list_stack.last.size
+    end
+
+    def check_nested_indent(s)
+      s.size >= @list_stack.last.size + 2
+    end
+
+    def check_inline_element_symbol(name)
+      INLINE.key?(name.to_sym)
+    end
+
+    def check_complex_inline_element_symbol(name)
+      COMPLEX_INLINE.key?(name.to_sym)
+    end
+
+    def position
+      Position.new(self)
+    end
+
+
+}
+
+%% ast-location = ::ReVIEW
+%% headline = ast HeadlineNode(compiler, position, level, cmd, label, content)
+%% paragraph = ast ParagraphNode(compiler, position, content)
+%% block_element = ast BlockElementNode(compiler, position, name, args, content)
+%% code_block_element = ast CodeBlockElementNode(compiler, position, name, args, content)
+%% inline_element = ast InlineElementNode(compiler, position, symbol, content)
+%% inline_element_content = ast InlineElementContentNode(compiler, position, content)
+%% complex_inline_element = ast ComplexInlineElementNode(compiler, position, symbol, content)
+%% complex_inline_element_content = ast ComplexInlineElementContentNode(compiler, position, content)
+%% text = ast TextNode(compiler, position, content)
+%% raw = ast RawNode(compiler, builder, position, content)
+%% brace = ast BraceNode(compiler, position, content)
+%% singleline_content = ast SinglelineContentNode(compiler, position, content)
+%% singleline_comment = ast SinglelineCommentNode(compiler, position, content)
+%% ulist = ast UlistNode(compiler, position, content)
+%% ulist_element = ast UlistElementNode(compiler, position, level, content)
+%% olist = ast OlistNode(compiler, position, content)
+%% olist_element = ast OlistElementNode(compiler, position, num, content)
+%% dlist = ast DlistNode(compiler, position, content)
+%% dlist_element = ast DlistElementNode(compiler, position, text, content)
+%% bracket_arg = ast BracketArgNode(compiler, position, content)
+%% document = ast DocumentNode(compiler, position, content)
+%% column = ast ColumnNode(compiler, position, level, label, caption, content)
+%% newline = ast NewLineNode(compiler, position, content)
+
+# %% dummy
+
+root = Start
+
+Start = &. { @list_stack = Array.new } Document:c { @strategy.ast = c }
+
+## a Document is a set of Blocks
+Document = BOM? Block*:c ~document(self, position, c)
+
+## ignore leading blank lines
+Block = BlankLine*:c { c }
+        ( SinglelineComment:c
+        | Headline:c
+        | BlockElement:c
+        | Ulist:c
+        | Olist:c
+        | Dlist:c
+        | Paragraph:c
+        ) { c }
+
+BlankLine = Newline
+
+SinglelineComment = ("#@" < NonNewline+ > EOL) ~singleline_comment(self, position, text)
+
+Headline =  HeadlinePrefix:level BracketArg?:cmd BraceArg?:label Space*  SinglelineContent?:caption EOL  ~headline(self, position, level, cmd, label, caption)
+
+HeadlinePrefix = < /={1,5}/ > { text.length }
+
+Paragraph = ParagraphLine+:c  ~paragraph(self, position, c.flatten)
+
+ParagraphLine = !Headline !SinglelineComment !BlockElement !Ulist !Olist !Dlist  SinglelineContent:c Newline { c }
+
+# There are 3 types of Block Element: raw Block, Code Block, and Normal Block
+BlockElement = ( "//raw[" RawBlockBuilderSelect?:b RawBlockElementArg*:r1 "]" Space* EOL
+                 ~raw(self, b, position, r1)
+               | !"//raw" "//" ElementName:symbol &{ syntax = syntax_descriptor(symbol); syntax && syntax.code_block? } BracketArg*:args "{" Space* Newline CodeBlockElementContents?:contents "//}" Space* EOL
+                  ~code_block_element(self, position, symbol, args, contents)
+               | !"//raw" "//" ElementName:symbol BracketArg*:args "{" Space* Newline BlockElementContents?:contents "//}" Space* EOL
+                  ~block_element(self, position, symbol, args, contents)
+               | !"//raw" "//" ElementName:symbol BracketArg*:args Space* EOL ~block_element(self, position, symbol, args, nil)
+               )
+
+RawBlockBuilderSelect = "|" Space* RawBlockBuilderSelectSub:c Space* "|" { c }
+
+RawBlockBuilderSelectSub = ( < AlphanumericAscii+ >:c1 Space* "," Space* RawBlockBuilderSelectSub:c2
+                             { [text] + c2 }
+                           | < AlphanumericAscii+ >:c1
+                             { [text] }
+                           )
+
+RawBlockElementArg = !"]" ( "\\]" { "]" }
+                          | "\\n" { "\n" }
+                          | < NonNewline >  { text }
+                          )
+
+BracketArg = "["  BracketArgInline*:content  "]" ~bracket_arg(self, position, content)
+
+## XXX '\' (excpet '\]' and '\\' ) => '\' is ???
+BracketArgInline = ( InlineElement:c { c }
+                   |  "\\]" ~text(self, position, "]")
+                   | "\\\\" ~text(self, position, "\\")
+                   | < /[^\r\n\]]/ >  ~text(self, position, text)
+                   )
+
+BraceArg = "{" < /([^\r\n}\\]|\\[^\r\n])*/ > "}" { text }
+
+## Standard BlockElement has nested blocks. Texts in content of block are parsed as Paragraph.
+BlockElementContents = BlockElementContent+:c { c }
+
+### Headline is prohibited.
+### Note: do not allow "//}" at front of Paragraph.
+BlockElementContent = ( SinglelineComment:c { c }
+                      | BlockElement:c { c }
+                      | Ulist:c
+                      | Dlist:c
+                      | Olist:c
+                      | BlankLine:c { c }
+                      | BlockElementParagraph:c { c }
+                      )
+
+## it's like Paragraph, but it's in a block, so do not allow '//}\n'
+BlockElementParagraph = BlockElementParagraphLine+:c  ~paragraph(self, position, c.flatten)
+BlockElementParagraphLine = !"//}" !BlankLine !SinglelineComment !BlockElement !Ulist !Olist !Dlist SinglelineContent:c Newline { c }
+
+## In CodeBlockElementContents, newline should no be ingored. So we use TextNode instead of NewLineNode.
+CodeBlockElementContents = CodeBlockElementContent+:c { c }
+CodeBlockElementContent = ( SinglelineComment:c { c }
+                          | BlankLine:c { ::ReVIEW::TextNode.new(self, position, "\n") }
+                          | !"//}" SinglelineContent:c Newline { [c, ::ReVIEW::TextNode.new(self, position, "\n")] }
+                          )
+
+## Ulist and Olist
+
+Bullet = "*"
+Enumerator = < /[0-9]+/ > { num = text } "." { num.to_i }
+
+Ulist = Indent+:s Bullet+:b Space+ { @list_stack.push(s) } UlistItemBlock:item
+        { if b.size > 1 then item.level = b.size end }
+        (UlistItem | UlistItemMore | NestedList)*:items &{ s == @list_stack.pop }
+        ~ulist(self, position, items.unshift(item))
+
+Olist = Indent+:s Enumerator:e Space+ { @list_stack.push(s) } OlistItemBlock:item
+        { item.num = e }
+        (OlistItem | NestedList)*:items &{ s == @list_stack.pop }
+        ~olist(self, position, items.unshift(item))
+
+UlistItemBlock = ListItemFirstLine:c ListItemLine*:d ~ulist_element(self, position, @list_stack.size, d.unshift(c))
+OlistItemBlock = ListItemFirstLine:c ListItemLine*:d ~olist_element(self, position, 0, d.unshift(c))
+
+ListItemFirstLine = SinglelineContent:c Newline { c }
+ListItemLine = Indent+:s !Bullet !Enumerator !Space SinglelineContent:c &{ check_indent(s) } Newline { c }
+
+UlistItemMore = Indent+:s Bullet Bullet+:b Space+ &{ check_indent(s) } UlistItemBlock:item { item.level = b.size+1; item }
+
+UlistItem = Indent+:s Bullet      Space+ &{ check_indent(s) } UlistItemBlock:item { item }
+OlistItem = Indent+:s Enumerator:e Space+ &{ check_indent(s) } OlistItemBlock:item { item.num = e; item }
+
+## NestedList is markdown-like indented syntax.
+## You can write nested Ulist and Olist with this syntax.
+
+NestedList = (NestedUlist | NestedOlist)
+
+NestedUlist = Indent+:s Bullet     Space+ &{ check_nested_indent(s) } { @list_stack.push(s) } UlistItemBlock:item
+        (UlistItem | NestedList)*:items &{ s == @list_stack.pop }
+        ~ulist(self, position, items.unshift(item))
+NestedOlist = Indent+:s Enumerator:e Space+ &{ check_nested_indent(s) } { @list_stack.push(s) } OlistItemBlock:item
+        { item.num = e }
+        (OlistItem | NestedList)*:items &{ s == @list_stack.pop }
+        ~olist(self, position, items.unshift(item))
+
+# Dlist
+Dlist = (DlistElement | SinglelineComment)+:content ~dlist(self, position, content)
+
+DlistElement = Indent* ":" Space+ SinglelineContent:text Newline DlistElementContent+:content ~dlist_element(self, position, text, content)
+
+DlistElementContent = (SinglelineComment:c { c }
+                      |Space+ SinglelineContent:c Newline { c }
+                      )
+
+SinglelineContent = Inline+:c ~singleline_content(self, position, c)
+
+
+# Inline Element and Non Inline Element
+
+Inline = ( InlineElement | NonInlineElement)
+
+NonInlineElement = !InlineElement < NonNewline > ~text(self, position, text)
+
+InlineElement =  ( RawInlineElement:c { c }
+                 | !RawInlineElement "@<" InlineElementSymbol:symbol ">" "{" InlineElementContents?:contents "}" ~inline_element(self, position, symbol,contents)
+                 | !RawInlineElement "@<" ComplexInlineElementSymbol:symbol ">" "{" ComplexInlineElementContents?:contents "}" ~complex_inline_element(self, position, symbol,contents)
+                 )
+
+RawInlineElement = "@<raw>{" RawBlockBuilderSelect?:builders RawInlineElementContent+:c "}" ~raw(self, builders, position, c)
+
+RawInlineElementContent = ( "\\}" { "}" }
+                          | < /[^\r\n\}]/ >  { text }
+                          )
+
+InlineElementSymbol = < AlphanumericAscii+ >:s &{ check_inline_element_symbol(text) } { text }
+
+InlineElementContents = !"}" InlineElementContentsSub:c { c }
+
+InlineElementContentsSub = !"}" Space* InlineElementContent:c1 Space* { [c1] }
+
+ComplexInlineElementSymbol = < AlphanumericAscii+ > &{ check_complex_inline_element_symbol(text) } { text }
+
+ComplexInlineElementContents = !"}" ComplexInlineElementContentsSub:c { c }
+
+ComplexInlineElementContentsSub = !"}" ( Space* InlineElementContent:c1 Space* "," ComplexInlineElementContentsSub:c2 {  [c1]+c2 }
+                                | Space* InlineElementContent:c1 Space* { [c1] }
+                                )
+
+
+InlineElementContent = InlineElementContentSub+:d { d }
+
+InlineElementContentSub = ( InlineElement:c { c }
+                          | !InlineElement QuotedInlineText:content ~inline_element_content(self, position, content)
+                          | !InlineElement InlineElementContentText+:content ~inline_element_content(self, position, content)
+                          )
+
+## Quoted Inline Text is "..."
+## In Quoted Inline Text, "\\" is "\", "\'" is "'", other characters are kept as is.
+QuotedInlineText =  "\""
+                            ( "\\\"" { "\"" }
+                            | "\\\\" { "\\" }
+                            | < /[^"\r\n\\]/ > { text }
+                            )+:str "\"" ~text(self, position, str.join(""))
+
+## XXX '\' (excpet '\}' and '\,' and '\\' ) => '\' is OK?
+InlineElementContentText =  ( "\\}" ~text(self, position, "}")
+                            | "\\," ~text(self, position, ",")
+                            | "\\\\" ~text(self, position, "\\" )
+                            | "\\" ~text(self, position, "\\" )
+                            | !InlineElement < /[^\r\n\\},]/> ~text(self, position, text)
+                            )
+
+NonNewline = /[^\r\n]/
+
+Space = /[ \t]/
+
+Indent = " "
+
+EOL = (Newline|EOF)
+
+EOF = !.
+
+ElementName = < LowerAlphabetAscii+ > { text }
+
+%literals         = ReVIEW::Compiler::Literals
+Alphanumeric      = %literals.Alphanumeric
+AlphanumericAscii = %literals.AlphanumericAscii
+LowerAlphabetAscii = %literals.LowerAlphabetAscii
+Digit              = %literals.Digit
+BOM               = %literals.BOM
+Newline           = %literals.Newline:n ~newline(self, position, "\n")
+NonAlphanumeric   = %literals.NonAlphanumeric
+Spacechar         = %literals.Spacechar