voodoo 0.7.0 → 1.0.0

data/lib/voodoo/parser.rb

@@ -1,3 +1,5 @@
+require 'voodoo/validator'
+
 module Voodoo
   # Voodoo parser.
   # The parser reads Voodoo[http://inglorion.net/documents/designs/voodoo/]
@@ -24,156 +26,118 @@ module Voodoo
     # the end of the input has been reached.
     def initialize input
       @input = input
-      @line = 1
-      @char = 0
+      @input_name = input.respond_to?(:path) ? input.path : nil
+      @start_line = @line = 1
+      @start_column = @column = 0
       @lookahead = nil
+      @text = ''
     end
 
-    # Consumes the current lookahead character
-    def consume
-      old = @lookahead
-      if old == 10
-        @line = @line.succ
-        @char = 0
+    class ParseError < StandardError
+      def initialize message, input_name, start_line, start_column, text
+        @message = message
+        @input_name = input_name
+        @start_line = start_line
+        @start_column = start_column
+        @text = text
       end
-      @lookahead = @input.getc
-      @lookahead = :eof if @lookahead == nil
-      @char = @char.succ unless @lookahead == :eof
-      old
-    end
 
-    # Returns the current lookahead character,
-    # or +nil+ when the end of the input has been reached.
-    def lookahead
-      if @lookahead == nil
-        @lookahead = @input.getc
-        @char = @char.succ
-      end
-      case @lookahead
-      when :eof
-        :eof
-      else
-        @lookahead.chr
-      end
+      attr_reader :message, :input_name, :start_line, :start_column, :text
     end
 
     # Parses a top-level element.
     # Returns an array containing the parts of the element.
-    # Eeach element of the array is a Symbol, a String, or an
-    # Integer.
     #
-    # For a label, returns:
-    #   [:label, label_name]
+    # Some examples (Voodoo code, Ruby return values in comments):
     #
-    # For a function definition, returns:
-    #   [:function, [formala, formalb, ...], [statementa, statementb, ...]]
-    #
-    # For a conditional, returns:
-    #   [condition, expression, [truea, trueb, ...], [falsea, falseb, ...]]
+    #   section functions
+    #   # [:section, :functions]
+    #   
+    #   call foo x 12
+    #   # [:call, :foo, :x, 12]
+    #   
+    #   set x add x 42
+    #   # [:set, :x, :add, :x, 42]
+    #   
+    #   set-byte @x 1 10
+    #   # [:"set-byte", [:"@", :x], 1, 10]
+    #   
+    #   ifeq x y
+    #       set z equal
+    #   else
+    #       set z not-equal
+    #   end if
+    #   # [:ifeq, [:x, :y], [[:set, :z, :equal]], [[:set, :z, :"not-equal"]]]
+    #   
+    #   foo:
+    #   # [:label, :foo]
+    #   
+    #   function x y
+    #       let z add x y
+    #       return z
+    #   end function
+    #   # [:function, [:x, :y], [:let, :z, :add, :x, :y], [:return, :z]]
     #
     def parse_top_level
-      words = []
-      word = ""
+      # Skip whitespace, comments, and empty lines
+      skip_to_next_top_level
 
-      while true
-        case lookahead
-        when :eof
-          # End of input
-          break
-        when "\n"
-          # Newline
-          consume
-          # Exit the loop, but only if the line wasn't empty
-          break unless words.empty?
-        when "#"
-          # Skip comment
-          while lookahead != :eof && lookahead != "\n"
-            word << lookahead
-            consume
-          end
-        when /\d|-/
-          # Digit; parse number
-          words << parse_number
-        when /\w|\\/
-          # Letter, underscore, or backslash; parse symbol
-          # Note: \w matches digites, too, so keep this case after \d
-          words << parse_symbol
-          if words.length == 1 && is_label?(words[-1])
-            # We have a label; return it
-            return [:label, words[-1].to_s[0..-2].to_sym]
-          end
-        when "\""
-          # Double quote; parse string
-          words << parse_string
-        when /\s/
-          # Skip whitespace
-          consume
-        when '@'
-          # Parse at-expression.
-          # '@' must be followed by a number or symbol.
-          consume
-          case lookahead
-          when /\d|-/
-            expr = parse_number
-          when /\w|\\/
-            expr = parse_symbol
-          else
-            raise "Invalid character (#{@lookahead.chr.inspect})" +
-              " at #{@line}:#{@char}; expecting number or symbol"
-          end
-          words << [:'@', expr]
-        else
-          raise "Invalid character (#{@lookahead.chr.inspect})" +
-            " at #{@line}:#{@char}"
-        end
-      end
-
-      # We have a line of input. Conditionals and function declarations
-      # must be handled specially, because they consist of more than one
-      # line.
-      if words.empty?
-        # Nothing to parse; return nil
-        nil
-      elsif words[0] == :function
-        # Function declaration. Parse function body
-        body = parse_body :function
-        [:function, words[1..-1], body]
-      elsif is_conditional?(words[0])
-        parse_conditional1 words[0], words[1..-1]
-      elsif words[0] == :block
-        body = parse_body :block
-        [:block] + body
-      else
-        # Statement or data declaration; simply return it
-        words
+      validate_top_level do
+        parse_top_level_nonvalidating
       end
     end
 
     # Parses a body for a function or a conditional
     def parse_body kind
       body = []
+      error = nil
       case kind
       when :function
         kind_text = 'function definition'
       else
         kind_text = kind.to_s
       end
-      while true
-        statement = parse_top_level
-        if statement == nil
-          raise "End of input while inside #{kind_text}"
-        elsif statement[0] == :end
-          # Done parsing body
-          break
-        elsif kind == :conditional && statement[0] == :else
-          # Done parsing body, but there is another one coming up
-          body << statement
-          break
-        else
-          # Parsed a statement. Add it to body.
-          body << statement
+      done = false
+      until done
+        begin
+          with_position do
+            statement = parse_top_level_nonvalidating
+            if statement == nil
+              done = true
+              parse_error "End of input while inside #{kind_text}", nil
+            elsif statement[0] == :end
+              # Done parsing body
+              done = true
+            elsif kind == :conditional && statement[0] == :else
+              # Done parsing body, but there is another one coming up
+              body << statement
+              done = true
+            else
+              # Should be a normal statement. Validate it, then add it to body
+              if statement[0] == :function
+                parse_error "Function definitions are only allowed at top-level"
+              end
+              begin
+                Validator.validate_statement statement
+                body << statement
+              rescue Validator::ValidationError => e
+                parse_error e.message
+              end
+            end
+          end
+        rescue => e
+          # Got some kind of error. Still try to parse the rest of the body.
+          # Save the error if it was the first one.
+          if error == nil
+            error = e
+          end
         end
       end
+
+      if error != nil
+        raise error
+      end
+
       body
     end
 
@@ -186,7 +150,7 @@ module Voodoo
       consume
       case lookahead
       when :eof
-        raise "Unexpected end of input in escape sequence"
+        parse_error "Unexpected end of input in escape sequence", nil
       when "\\", "\"", " "
         result = lookahead
         consume
@@ -201,8 +165,9 @@ module Voodoo
       when "x"
         # \xXX is byte with hex value XX
         code = @input.read 2
-        @char = @char + 2
+        @column = @column + 2
         consume
+        @text << code
         result = [code].pack('H2')
       when "\n"
         # \<newline> is line continuation character
@@ -278,6 +243,26 @@ module Voodoo
       name.to_sym
     end
 
+    #
+    # Private methods
+    #
+    private
+
+    # Consumes the current lookahead character.
+    # The character is appended to @text.
+    def consume
+      old = @lookahead
+      if old == 10
+        @line = @line.succ
+        @column = 0
+      end
+      @lookahead = @input.getc
+      @lookahead = :eof if @lookahead == nil
+      @column = @column.succ unless @lookahead == :eof
+      @text << old
+      old
+    end
+
     # Tests if a symbol is a label
     def is_label? symbol
       symbol.to_s[-1] == ?:
@@ -288,10 +273,20 @@ module Voodoo
       [:ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne].member? symbol
     end
 
-    #
-    # Private methods
-    #
-    private
+    # Returns the current lookahead character,
+    # or +nil+ when the end of the input has been reached.
+    def lookahead
+      if @lookahead == nil
+        @lookahead = @input.getc
+        @column = @column.succ
+      end
+      case @lookahead
+      when :eof
+        :eof
+      else
+        @lookahead.chr
+      end
+    end
 
     # Parses a conditional statement
     def parse_conditional1 condition, operands
@@ -311,6 +306,116 @@ module Voodoo
       [condition, operands, consequent, alternative]
     end
 
+    # Raises a ParseError at the current input position
+    def parse_error message, text = @text
+      # Create the error object
+      error = ParseError.new(message, @input_name, @start_line,
+                             @start_column, text)
+
+      # Set a backtrace to the calling method
+      error.set_backtrace caller
+
+      # If we are not at a new line, skip until the next line
+      while @column != 1 && lookahead != :eof
+        consume
+      end
+
+      # Raise the error
+      raise error
+    end
+
+    # Parses a top-level directive without validating it
+    def parse_top_level_nonvalidating
+      # Skip whitespace, comments, and empty lines
+      skip_to_next_top_level
+
+      words = []
+      while true
+        # Parse next token
+        skip_whitespace
+        word = try_parse_token
+        if word == nil
+          # Word is nil; that means we did not get a token
+          case lookahead
+          when :eof
+            # End of input
+            break
+          when "\n"
+            # Newline
+            consume
+            # Exit the loop, but only if the line wasn't empty
+            break unless words.empty?
+          when "#"
+            # Skip comment
+            while lookahead != :eof && lookahead != "\n"
+              word << lookahead
+              consume
+            end
+          else
+            parse_error "Unexpected character (#{lookahead}) in input"
+          end
+        else
+          # Word is not nil - we got a token
+          if words.empty? && word.kind_of?(::Symbol) && word.to_s[-1] == ?:
+            # First word is a label
+            words = [:label, word.to_s[0..-2].to_sym]
+            break
+          end
+          # Add word to statement
+          words << word
+        end
+      end
+
+      # We have a line of input. Conditionals and function declarations
+      # must be handled specially, because they consist of more than one
+      # line.
+      if words.empty?
+        # Nothing to parse; return nil
+        nil
+      elsif words[0] == :function
+        # Function declaration. Parse function body
+        body = parse_body :function
+        [:function, words[1..-1]] + body
+      elsif is_conditional?(words[0])
+        parse_conditional1 words[0], words[1..-1]
+      elsif words[0] == :block
+        body = parse_body :block
+        [:block] + body
+      else
+        # Statement or data declaration; simply return it
+        words
+      end
+    end
+
+    # Skips whitespace, newlines, and comments before a top-level directive
+    def skip_to_next_top_level
+      while true
+        case lookahead
+        when /\s/
+          # Skip whitespace
+          consume
+        when "\n"
+          # Newline
+          consume
+        when "#"
+          # Skip comment
+          while lookahead != :eof && lookahead != "\n"
+            consume
+          end
+        else
+          break
+        end
+      end
+    end
+
+    # Consumes characters until a character other than space or tab is
+    # encountered.
+    def skip_whitespace
+      while lookahead == " " || lookahead == "\t"
+        consume
+      end
+    end
+
     # Splits a parsed if-clause into two parts:
     # 1. The list of statements making up the clause proper
     # 2. The condition for the next clause:
@@ -335,5 +440,79 @@ module Voodoo
       end
     end
 
+    # Tries to parse a symbol, number, string, or at-expression. If
+    # such a token starts at the current position, it is parsed and returned.
+    # Else, nil is returned.
+    def try_parse_token
+      case lookahead
+      when /\d|-/
+        # Digit; parse number
+        parse_number
+      when /\w|\\/
+        # Letter, underscore, or backslash; parse symbol
+        # Note: \w matches digits, too, so keep this case after \d
+       parse_symbol
+      when "\""
+        # Double quote; parse string
+        parse_string
+      when '@'
+        # Parse at-expression.
+        # '@' must be followed by a number or symbol.
+        consume
+        case lookahead
+        when /\d|-/
+          expr = parse_number
+        when /\w|\\/
+          expr = parse_symbol
+        else
+          parse_error "Invalid character (#{lookahead}) " +
+            "in at-expression; expecting number or symbol"
+        end
+        [:'@', expr]
+      else
+        # No valid starter for a token, return nil
+        nil
+      end
+    end
+
+    # Evaluate block and check that the result is a valid top-level
+    # directive.
+    def validate_top_level &block
+      with_position do
+        result = yield
+        begin
+          if result != nil
+            Validator.validate_top_level result
+          end
+          result
+        rescue Validator::ValidationError => e
+          parse_error e.message
+        end
+      end
+    end
+
+    # Evaluate block, keeping track of @start_line, @start_column
+    # at the beginning of the block, and @text during the evaluation
+    # of block.
+    def with_position &block
+      # Save old values
+      old_line = @start_line
+      old_column = @start_column
+      old_text = @text
+
+      # Evaluate block with new values
+      begin
+        @start_line = @line
+        @start_column = @column
+        @text = ''
+        yield
+      ensure
+        # Restore old values
+        @start_line = old_line
+        @start_column = old_column
+        @text = old_text + @text
+      end
+    end
+
   end
 end