fdlint 0.1.3 → 0.2.0.pre

data/lib/fdlint/parser/js/expr/operate.rb

@@ -0,0 +1,94 @@
+module Fdlint
+  module Parser
+    module JS
+      module Expr
+        
+        module Operate
+       
+          def parse_expr_postfix
+            log 'parse expr postfix'
+            expr = parse_expr_lefthand
+            if check(/[ \t]*(?:\+\+|--)/, true)
+              op = scan /\+\+|--/
+              expr = create_element Expression, op.text, expr
+            end
+            expr
+          end
+
+          def parse_expr_unary
+            log 'parse expr unary'
+            r = /delete|void|typeof|\+\+|--|\+|-|~|!/
+            if check r
+              op = scan r
+              create_element Expression, op.text, nil, parse_expr_unary, scanner_pos
+            else
+              parse_expr_postfix
+            end
+          end
+
+          def parse_expr_mul
+            log 'parse expr mul'
+            parse_expr_with_operate :parse_expr_unary, /(?:\*|\/|%)(?!=)/
+          end
+
+          def parse_expr_add
+            log 'parse expr add'
+            parse_expr_with_operate :parse_expr_mul, /(?:\+|-)(?!=)/
+          end
+
+          def parse_expr_shift
+            log 'parse expr shift'
+            parse_expr_with_operate :parse_expr_add, /(?:<<|>>>|>>)(?!=)/
+          end
+
+          def parse_expr_relation
+            not_in = expr_operate_not_in?
+            log "parse expr relational#{not_in ? '(notin)' : ''}"
+            pattern = not_in ? (/>=|<=|>|<|\binstanceof\b/) : (/>=|<=|>|<|\binstanceof\b|\bin\b/)
+            parse_expr_with_operate :parse_expr_shift, pattern 
+          end
+
+          def parse_expr_equal
+            log 'parse expr equal'
+            parse_expr_with_operate :parse_expr_relation, /===|!==|==|!=/
+          end
+
+          def parse_expr_bit_and
+            log 'parse expr bit and'
+            parse_expr_with_operate :parse_expr_equal, /&(?![&=])/
+          end
+
+          def parse_expr_bit_xor
+            log 'parse expr bit xor'
+            parse_expr_with_operate :parse_expr_bit_and, /\^(?!=)/
+          end
+
+          def parse_expr_bit_or
+            log 'parse expr bit or'
+            parse_expr_with_operate :parse_expr_bit_xor, /\|(?![|=])/
+          end
+
+          def parse_expr_logical_and
+            log 'parse expr logical and'
+            parse_expr_with_operate :parse_expr_bit_or, /&&/
+          end
+
+          def parse_expr_logical_or
+            log 'parse expr logical or'
+            parse_expr_with_operate :parse_expr_logical_and, /\|\|/
+          end
+
+          def expr_operate_not_in?
+            @operate_not_in || false
+          end
+
+          def expr_operate_not_in=(value)
+            @operate_not_in = !!value
+          end
+          
+        end
+
+      end
+    end
+  end
+end

data/lib/fdlint/parser/js/expr/primary.rb

@@ -0,0 +1,168 @@
+module Fdlint
+  module Parser
+    module JS
+      module Expr
+        
+        module Primary
+        
+          R_IDENTIFY = /[a-zA-Z_$][\w$]*/
+
+          RESERVED_WORDS = %w(
+              break case catch continue debugger default delete do else 
+              finally for function if in instanceof new return switch this
+              throw try typeof var void while with
+              class const enum export extends import super
+              implements interface let package private protected public static yield
+              null true false
+          )
+
+          R_THIS_NULL_BOOLEAN = /(?:this|null|true|false)\b/
+          R_HEX = /0[xX]/
+          R_NUMBERIC = /[+-]?(?:\d|(?:[.]\d))/
+          R_STRING = /['"]/
+          R_REGEXP = /\/[^\/]/
+
+          def parse_expr_primary
+            log "parse expr primary"
+            if check /\(/
+              parse_expr_parentheses
+
+            elsif check /\[/
+              parse_expr_array
+
+            elsif check /\{/
+              parse_expr_object
+          
+            # literal 
+            elsif check R_THIS_NULL_BOOLEAN 
+              parse_expr_literal_this_null_boolean
+
+            elsif check R_HEX
+              parse_expr_literal_hex
+
+            elsif check R_NUMBERIC
+              parse_expr_literal_number
+
+            elsif check R_STRING
+              parse_expr_literal_string
+
+            elsif check R_REGEXP
+              parse_expr_literal_regexp
+            #~
+            
+            else
+              parse_expr_identifier
+            end
+          end
+
+          def parse_expr_parentheses
+            log 'parse expr parentheses'
+
+            pos = skip /\(/
+            expr = parse_expression
+            skip /\)/
+            
+            create_expression 'parentheses', expr, pos
+          end
+
+          def parse_expr_array
+            log 'parse expr array'
+
+            pos = skip /\[/
+            elms = batch(:parse_expr_assignment, /\]/, /,/)
+            skip /\]/
+
+            create_expression 'array', Elements.new(elms), pos 
+          end
+
+          def parse_expr_object
+            log 'parse expr object'
+
+            pos = skip /\{/
+            elms = batch(:parse_expr_object_item, /\}/, /,/)
+            skip /\}/
+
+            create_expression 'object', Elements.new(elms), pos
+          end
+
+          def parse_expr_object_item
+            log 'parse expr object item'
+
+            name = if check R_STRING
+              parse_expr_literal_string
+            elsif check R_NUMBERIC
+              parse_expr_literal_number
+            else
+              parse_expr_identifier
+            end
+
+            skip /:/
+            value = parse_expr_assignment
+            
+            Expression.new ':', name, value
+          end
+
+          def parse_expr_identifier
+            log 'parse expr identifier'
+
+            id = scan(R_IDENTIFY)
+            RESERVED_WORDS.include?(id.text) ? 
+                parse_error("identifier can not be reserved word: #{id}") : id
+          
+            create_expression 'id', id
+          end
+
+          def parse_expr_literal_this_null_boolean
+            log 'parse expr literal this null boolean'
+            expr = scan /this|null|true|false/
+            type = expr.text.gsub(/true|false/, 'boolean')
+
+            create_expression type, expr 
+          end
+
+          def parse_expr_literal_string
+            log 'parse expr literal string'
+
+            expr = if check /'/
+              scan /'(?:(?:\\')|(?:\\\n)|[^'\n])*'/
+            elsif check /"/
+              scan /"(?:(?:\\")|(?:\\\n)|[^"\n])*"/
+            else
+              raise 'assert false'
+            end
+
+            create_expression 'string', expr 
+          end
+
+          def parse_expr_literal_hex
+            log 'parse expr literal hex'
+            expr = scan /0[xX][0-9a-fA-F]+/
+            create_expression 'number', expr
+          end
+
+          def parse_expr_literal_number
+            log 'parse expr literal number'
+            expr = scan /[+-]?(?:(?:\d*[.]\d+)|(?:\d+))(?:[eE][+-]?\d+)?/
+            create_expression 'number', expr
+          end
+
+          def parse_expr_literal_regexp
+            log 'parse expr literal regexp'
+            expr = scan %r{/(?:(?:\\.)|(?:\[(?:\\.|[^\[\]])+\])|[^/\\])+/[a-z]*}
+            create_expression 'regexp', expr
+          end
+
+          private
+
+          def create_expression(*args)
+            expr = PrimaryExpression.new *args
+            log "  #{expr}"
+            expr
+          end
+
+        end
+
+      end
+    end 
+  end
+end

data/lib/{js/parser.rb → fdlint/parser/js/js_parser.rb}

@@ -1,22 +1,23 @@
-require_relative '../base_parser'
-require_relative 'struct'
+require 'fdlint/parser/base_parser'
+require 'fdlint/parser/js/struct'
+require 'fdlint/parser/js/expr/expr'
+require 'fdlint/parser/js/stat/stat'
 
-require_relative 'expr/expr'
-require_relative 'stat/stat'
 
+module Fdlint; module Parser
 
-module XRay
   module JS
     
-    class Parser < XRay::BaseParser
+    class JsParser < Fdlint::Parser::BaseParser
 
       include Expr::Expr
       include Stat::Stat
+      include ::Fdlint::Parser::ParserVisitable
 
       attr_reader :singleline_comments, :mutiline_comments
 
-      def initialize(js, logger)
-        super js, logger
+      def initialize(js)
+        super
         @singleline_comments, @mutiline_comments = [], []
       end
 
@@ -113,4 +114,5 @@ module XRay
     end
 
   end
-end
+
+end; end

data/lib/fdlint/parser/js/stat/if.rb

@@ -0,0 +1,27 @@
+module Fdlint
+  module Parser
+    module JS
+      module Stat
+
+        module If
+          def parse_stat_if
+            log 'parse stat if'
+
+            pos = skip /if\s*\(/
+            condition = parse_expression
+            skip /\)/
+
+            true_part = parse_statement
+            false_part = if check /else\b/
+              skip /else/
+              parse_statement
+            end
+            
+            create_element IfStatement, condition, true_part, false_part, pos
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fdlint/parser/js/stat/iter.rb

@@ -0,0 +1,88 @@
+module Fdlint
+  module Parser
+    module JS
+      module Stat
+        
+        # 循环语句
+        module Iter
+
+          def parse_stat_dowhile
+            log 'parse stat dowhile'
+
+            pos = skip /do/
+            body = parse_statement
+
+            skip /while\s*\(/
+            condition = parse_expression
+            skip /\)/ 
+            
+            create_element DowhileStatement, body, condition, pos
+          end 
+
+          def parse_stat_while
+            log 'parse stat while'
+
+            pos = skip /while\s*\(/
+            condition = parse_expression
+            skip /\)/
+            body = parse_statement
+
+            create_element WhileStatement, condition, body, pos
+          end
+
+          def parse_stat_for
+            log 'parse stat for'
+
+            pos = skip /for/
+            
+            con_pos = skip /\(/
+            first, is_var = parse_stat_for_con_first
+            type, second, third = parse_stat_for_con_other(first, is_var)
+            skip /\)/
+
+            condition = create_element ForConditionElement, type, first, second, third, con_pos
+            body = parse_statement
+            create_element ForStatement, condition, body, pos
+          end
+
+          private
+
+          def parse_stat_for_con_first
+            self.expr_operate_not_in = true
+            first = if check /var\b/
+              skip /var/
+              is_var = true 
+              parse_stat_var_declarationlist
+            elsif !check(/;/)
+              parse_expression 
+            end
+            self.expr_operate_not_in = false
+            [first, is_var]
+          end
+
+          def parse_stat_for_con_other(first, is_var)
+            if check /in\b/
+              if is_var && first.length != 1 || !is_var && !first.left_hand?
+                parse_error('first expression of for-condtion error')
+              end
+
+              skip /in/
+              type = is_var ? 'forvarin' : 'forin'
+              second = parse_expression
+            else
+              skip /;/
+              type = is_var ? 'forvar' : 'fordefault'
+              second = check(/;/) ? nil : parse_expression
+              skip /;/
+
+              third = check(/\)/) ? nil : parse_expression
+            end
+            [type, second, third]
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fdlint/parser/js/stat/stat.rb

@@ -0,0 +1,120 @@
+require_relative 'var'
+require_relative 'if'
+require_relative 'switch'
+require_relative 'iter'
+require_relative 'try'
+
+module Fdlint
+  module Parser
+    module JS
+      module Stat 
+        
+        # Stat : Statement node.
+        module Stat
+
+          include Var, If, Switch, Iter, Try
+
+          def parse_statement
+            # 在ruby-1.8下map是无序的,所以这里只能用数组来实现
+            map = [
+              /\{/,         'block',
+              /\;/,         'empty',
+              /var\b/,      'var',
+              /if\b/,       'if',
+              /switch\b/,   'switch',
+              /do\b/,       'dowhile',
+              /while\b/,    'while',
+              /for\b/,      'for',
+              /continue\b/, 'continue',
+              /break\b/,    'break',
+              /return\b/,   'return',
+              /throw\b/,    'throw',
+              /try\b/,      'try',
+              /./,          'expression'
+            ] 
+
+            0.upto(map.size / 2 - 1) do |i|
+              if check(map[i * 2])
+                return self.send('parse_stat_' + map[i * 2 + 1])
+              end
+            end
+          end
+
+          def parse_stat_block
+            log 'parse stat block'
+            
+            pos = skip /\{/
+            stats = batch(:parse_statement, /\}/)
+            skip /\}/ 
+
+            create_element BlockStatement, Elements.new(stats), pos
+          end
+
+          def parse_stat_empty
+            log 'parse stat empty'
+            pos = skip /;/
+            
+            stat = create_element Statement, 'empty'
+            stat.end_with_semicolon = true
+            stat
+          end
+
+          def parse_stat_expression
+            log 'parse stat expression'
+
+            expr = parse_expression
+            stat = create_element ExpressionStatement, expr
+            after_parse_statement stat
+          end
+
+          def parse_stat_continue
+            log 'parse stat continue'
+            parse_stat_simple /continue/, :parse_expr_identifier
+          end
+
+          def parse_stat_break
+            log 'parse stat break'
+            parse_stat_simple /break/, :parse_expr_identifier
+          end
+
+          def parse_stat_return
+            log 'parse stat return'
+            parse_stat_simple /return/, :parse_expression
+          end
+
+          def parse_stat_throw
+            log 'parse stat throw'
+            parse_stat_simple /throw/, :parse_expression
+          end
+
+          def parse_stat_label
+            log 'parse stat label'
+            raise 'not impelments'
+          end
+
+          def after_parse_statement(stat)
+            skip /[ \t]*/, true
+            colon = !!check(/;/, true)
+            stat.end_with_semicolon = colon
+            colon ? skip(/;/, true) :
+                (eos? || check(/\}/)) ? nil : skip(/\n/, true)
+            stat
+          end
+
+          private
+
+          def parse_stat_simple(pattern, action)
+            type = scan pattern
+            skip /[ \t]*/, true
+            left = (eos? || check(/[;\n}]/, true)) ? nil : self.send(action)
+            
+            stat = create_element Statement, type.text, left, nil, type.position
+            after_parse_statement stat
+          end
+
+        end
+         
+      end
+    end
+  end
+end

data/lib/fdlint/parser/js/stat/switch.rb

@@ -0,0 +1,67 @@
+module Fdlint
+  module Parser
+    module JS
+      module Stat
+        
+        module Switch
+          def parse_stat_switch
+            log 'parse stat switch'
+
+            pos = skip /switch\s*\(/
+            expression = parse_expression
+            skip /\)/
+            block = parse_stat_caseblock
+            
+            create_element SwitchStatement, expression, block, pos
+          end
+
+          def parse_stat_caseblock
+            log 'parse stat caseblock'
+
+            pos = skip /\{/
+            case_clauses = check(/case\b/) ? parse_stat_caseclauses : nil
+            default_clause = check(/default\b/) ? parse_stat_defaultclause : nil
+            bottom_case_clauses = check(/case\b/) ? parse_stat_caseclauses : nil
+            skip /\}/
+
+            create_element CaseBlockStatement, case_clauses, default_clause, 
+                bottom_case_clauses, pos
+          end
+
+          def parse_stat_caseclauses
+            log 'parse stat caseclauses'
+            stats = batch(:parse_stat_caseclause, /default\b|\}/)
+            create_element Elements, stats 
+          end
+
+          def parse_stat_caseclause
+            log 'parse stat caseclause'
+
+            pos = skip /case/
+            expr = parse_expression
+            skip /:/
+            stats = parse_statement_list
+            create_element Statement, 'caseclause', expr, stats, pos
+          end
+
+          def parse_stat_defaultclause
+            log 'parse stat defaultclause'
+
+            pos = skip /default\s*:/
+            stats = parse_statement_list 
+            create_element Statement, 'defaultclause', stats, nil, pos
+          end
+
+          private
+
+          def parse_statement_list
+            elms = batch(:parse_statement, /case\b|default\b|\}/)
+            Elements.new elms
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fdlint/parser/js/stat/try.rb

@@ -0,0 +1,30 @@
+module Fdlint
+  module Parser
+    module JS
+      module Stat
+        
+        module Try
+          def parse_stat_try
+            pos = skip /try/
+            try_part = parse_stat_block
+
+            catch_part = if check /catch\b/
+              catch_pos = skip /catch\s*\(/
+              id = parse_expr_identifier
+              skip /\)/
+              create_element Statement, 'catch', id, parse_stat_block, catch_pos
+            end
+            
+            finally_part = if check /finally\b/
+              skip /finally/
+              parse_stat_block
+            end
+
+            create_element TryStatement, try_part, catch_part, finally_part, pos
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fdlint/parser/js/stat/var.rb

@@ -0,0 +1,42 @@
+module Fdlint
+  module Parser
+    module JS
+      module Stat
+        
+        module Var
+          def parse_stat_var
+            log 'parse stat var'
+
+            pos = skip /var/
+
+            decs = parse_stat_var_declarationlist
+            stat = create_element VarStatement, decs, pos
+            after_parse_statement stat
+          end
+
+          def parse_stat_var_declarationlist
+            log 'parse stat var declarationlist'
+            decs = []
+            decs << parse_stat_var_declaration 
+            while check /,/
+              skip /,/
+              decs << parse_stat_var_declaration
+            end
+            create_element Elements, decs
+          end
+
+          def parse_stat_var_declaration 
+            log 'parse stat var declaration'
+            name = parse_expr_identifier
+            expr = if check(/\=/)
+              skip /\=/
+              parse_expr_assignment
+            end
+            create_element Statement, 'var=', name, expr
+          end
+        end
+
+      end
+    end
+  end
+end