Kwartz::Parser (Class)

In: kwartz.rb
Parent: Object

usage. 

  input = <<END
    :if(ctr % 2 == 0)
      :print('even')
    :else
      :print('odd')
    :end
  END
  scanner = Kwartz::Scanner.new(input)
  parser   = Kwartz::Parser.new(scanner)
  nodelist = parser.parse()

Constants

METHOD_DISPATHER = { :set => :parse_stmt_set, :if => :parse_stmt_if, :while => :parse_stmt_while, :foreach => :parse_stmt_foreach, :print => :parse_stmt_print, :macro => :parse_stmt_macro, :elem => :parse_stmt_elem, :expand => :parse_stmt_expand, :expand2 => :parse_stmt_expand2, :stag => :parse_stmt_specialexpand, :cont => :parse_stmt_specialexpand, :etag => :parse_stmt_specialexpand, :value => :parse_stmt_value, :rawcode => :parse_stmt_rawcode, ':::' => :parse_stmt_rawcode, :load => :parse_stmt_load, }
 

Public Class methods

prior?(op1, op2)

compare priority of operators. this is called from Translator#translate_expr().

return true if op1 > op2, nil if op1 == op2, false if op1 < op2.

Public Instance methods

parse()

main parse method

parse_arith()
  • BNF: 
     arith2 ::= term | term '+' arith | term '-' arith | term '.+' arith
 arith  ::= unary | unary '+' arith2 | unary '-' arith2 | unary '.+' arith2
        ::= unary { ('+' | '-' | '.+') term }
parse_array()
  • BNF: 
     array ::= item | item '[' expr ']' | item '{' expr '}'
                | item '[:' name ']' | item '.' property
      ::= item { '[' expr ']' | '{' expr '}' | '[:' name ']' | '.' propperty }
parse_assignment(flag_foreach_stmt=false)
  • BNF: 
     assignment ::= expression         assign-op expression | expression
           ::= expression [ assign-op expression ]
parse_compare()
  • BNF: 
     compare-op ::=   '==' |  '!=' |  '>' |  '>=' |  '<' |  '<='
              | '.==' | '.!=' | '.>' | '.>=' | '.<' | '.<='
 compare   ::= arith compare-op arith | arith ['==' | '!='] 'empty'
parse_expression()
  • BNF: 
     expression ::= logical-or | logical-or '?' logical-or ':' logical-or
           ::= logical-or { '?' logical-or ':' logical-or }
parse_factor()
  • BNF: 
     factor ::= array | number | string | 'true' | 'false' | 'nil'
parse_item()
  • BNF: 
     item ::= variable | function '(' [expr {',' expr}] ')' | '(' expression ')'
parse_logical_and()
  • BNF: 
     logical-and ::= compare '&&' logical-and
            ::= compare { '&&' compare }
parse_logical_or()
  • BNF: 
     logical-or ::= logical-and '||' logical-or
           ::= logical-and { '||' logical-and }
parse_stmt_elem()
  • BNF: 
     elem-stmt  ::= ':elem'  '(' name ')' stmt-list ':end'
  • return node:
    token::macro
    left:name String
    right:NodeList
parse_stmt_expand()
  • BNF: 
     expand-stmt ::= ':expand' '(' name ')'
  • return node:
    token::expand
    left:name String
    right:nil
parse_stmt_expand2()
  • BNF: 
      expand2-stmt ::= '@' macro-name
  • return node:
    token::expand
    left:name String
    right:nil
parse_stmt_foreach()
  • BNF: 
     foreach-stmt ::= ':foreach' '(' expression '=' expression ')'
                 stmt-list ':end'
  • return node:
    token::foreach
    left:assignment ExprNode
    right:NodeList
parse_stmt_if()
  • BNF: 
     if-stmt ::= ':if' '(' expression ')' stmt-list
           { ':elsif' '(' expression ')' stmt-list }
           [ ':else' stmt-list ] ':end'
  • return node
    token::if
    left:NodeList
    right:if StmtNode (when :elsif) / NodeList (when no :elsif)
    condition:ExprNode
parse_stmt_list()
  • BNF: 
     stmt     ::= set-stmt | if-stmt | while-stmt | foreach-stmt
             | print-stmt | macro-stmt | expand-stmt | rawcode-stmt
             | print2-stmt
 stmt-list ::= stmt*
  • return node: NodeList
parse_stmt_load()
  • BNF: 
     load-stmt ::= ':load' '(' string ')'
  • return: nodelist
parse_stmt_macro()
  • BNF: 
     macro-stmt ::= ':macro' '(' name ')' stmt-list ':end'
  • return node:
    token::macro
    left:name String
    right:NodeList
parse_stmt_print()
  • BNF: 
     print-stmt ::= ':print'  '(' expression { ',' expression } ')'
  • return node:
    token::print
    left:expression ExprNode
    right:nil
parse_stmt_rawcode()
  • BNF: 
     rawcode ::= ':::' raw-string | ':rawcode' '(' string ')'
  • return node:
    token::rawcode
    left:rawcode String
    right:nil
parse_stmt_set()
  • BNF: 
     set-stmt ::= ':set' '(' assignment ')'
  • return node:
    token::set
    left:assignment ExprNode
    right:nil
parse_stmt_specialexpand()
  • BNF: 
      special-expand-stmt ::= '@stag' | '@cont' | '@etag' | ':stag' | ':cont' | ':etag'
  • return node:
    token::expand
    left:name String
    right:nil
parse_stmt_value()
  • BNF: 
      value-stmt ::= ':value' '(' name '=' expression ')'
  • return node:
    token::value
    left:name String (‘cont_’ + name)
    right:NodeList (of PrintStmtNode)
parse_stmt_while()
  • BNF: 
     while-stmt ::= ':while' '(' assignment ')' stmt-list ':end'
  • return node:
    token::while
    left:NodeList
    right:nil
    condition:expression ExprNode
parse_term()
  • BNF: 
     term ::= factor | factor '*' term | factor '/' term | factor '%' term | factor
     ::= factor { ('*' | '/' | '%') factor }
parse_unary()
  • BNF: 
     unary ::= [ '+' | '-' | '!' ] term

[Validate]