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

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

main parse method

  • BNF:
     arith2 ::= term | term '+' arith | term '-' arith | term '.+' arith
     arith  ::= unary | unary '+' arith2 | unary '-' arith2 | unary '.+' arith2
            ::= unary { ('+' | '-' | '.+') term }
    
  • BNF:
     array ::= item | item '[' expr ']' | item '{' expr '}'
                    | item '[:' name ']' | item '.' property
          ::= item { '[' expr ']' | '{' expr '}' | '[:' name ']' | '.' propperty }
    
  • BNF:
     assignment ::= expression         assign-op expression | expression
               ::= expression [ assign-op expression ]
    
  • BNF:
     compare-op ::=   '==' |  '!=' |  '>' |  '>=' |  '<' |  '<='
                  | '.==' | '.!=' | '.>' | '.>=' | '.<' | '.<='
     compare   ::= arith compare-op arith | arith ['==' | '!='] 'empty'
    
  • BNF:
     expression ::= logical-or | logical-or '?' logical-or ':' logical-or
               ::= logical-or { '?' logical-or ':' logical-or }
    
  • BNF:
     factor ::= array | number | string | 'true' | 'false' | 'nil'
    
  • BNF:
     item ::= variable | function '(' [expr {',' expr}] ')' | '(' expression ')'
    
  • BNF:
     logical-and ::= compare '&&' logical-and
                ::= compare { '&&' compare }
    
  • BNF:
     logical-or ::= logical-and '||' logical-or
               ::= logical-and { '||' logical-and }
    
  • BNF:
     elem-stmt  ::= ':elem'  '(' name ')' stmt-list ':end'
    
  • return node:
    token::macro
    left:name String
    right:NodeList
  • BNF:
     expand-stmt ::= ':expand' '(' name ')'
    
  • return node:
    token::expand
    left:name String
    right:nil
  • BNF:
      expand2-stmt ::= '@' macro-name
    
  • return node:
    token::expand
    left:name String
    right:nil
  • BNF:
     foreach-stmt ::= ':foreach' '(' expression '=' expression ')'
                     stmt-list ':end'
    
  • return node:
    token::foreach
    left:assignment ExprNode
    right:NodeList
  • 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
  • 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
  • BNF:
     load-stmt ::= ':load' '(' string ')'
    
  • return: nodelist
  • BNF:
     macro-stmt ::= ':macro' '(' name ')' stmt-list ':end'
    
  • return node:
    token::macro
    left:name String
    right:NodeList
  • BNF:
     print-stmt ::= ':print'  '(' expression { ',' expression } ')'
    
  • return node:
    token::print
    left:expression ExprNode
    right:nil
  • BNF:
     rawcode ::= ':::' raw-string | ':rawcode' '(' string ')'
    
  • return node:
    token::rawcode
    left:rawcode String
    right:nil
  • BNF:
     set-stmt ::= ':set' '(' assignment ')'
    
  • return node:
    token::set
    left:assignment ExprNode
    right:nil
  • BNF:
      special-expand-stmt ::= '@stag' | '@cont' | '@etag' | ':stag' | ':cont' | ':etag'
    
  • return node:
    token::expand
    left:name String
    right:nil
  • BNF:
      value-stmt ::= ':value' '(' name '=' expression ')'
    
  • return node:
    token::value
    left:name String (‘cont_’ + name)
    right:NodeList (of PrintStmtNode)
  • BNF:
     while-stmt ::= ':while' '(' assignment ')' stmt-list ':end'
    
  • return node:
    token::while
    left:NodeList
    right:nil
    condition:expression ExprNode
  • BNF:
     term ::= factor | factor '*' term | factor '/' term | factor '%' term | factor
         ::= factor { ('*' | '/' | '%') factor }
    
  • BNF:
     unary ::= [ '+' | '-' | '!' ] term
    

[Validate]