voodoo 1.0.0 → 1.0.1

data/lib/voodoo/compiler.rb

@@ -54,13 +54,17 @@ module Voodoo
             @generator.add section, statement
           end
 
+        rescue Parser::MultipleErrors => e
+          errors.concat e.errors
+
         rescue Parser::ParseError => e
           errors << e
-          if errors.length >= 100
-            raise Error.new(errors)
-          end
         end
 
+        if errors.length >= 100
+          # Too many errors, give up.
+          raise Error.new(errors)
+        end
       end
 
       if errors.empty?

data/lib/voodoo/config.rb

@@ -2,7 +2,7 @@ module Voodoo
   # Methods to get and set configuration parameters
   module Config
     IMPLEMENTATION_NAME = 'Voodoo Compiler'
-    IMPLEMENTATION_VERSION = '1.0.0'
+    IMPLEMENTATION_VERSION = '1.0.1'
 
     # Class that holds configuration parameters
     class Configuration

data/lib/voodoo/parser.rb

@@ -33,16 +33,83 @@ module Voodoo
       @text = ''
     end
 
-    class ParseError < StandardError
+    # Base class for errors reported from the parser.
+    # This provides methods to get the name of the input being processed,
+    # as well as the start_line, start_column, and text of the code
+    # that triggered the error.
+    class Error < StandardError
       def initialize message, input_name, start_line, start_column, text
-        @message = message
+        super message
         @input_name = input_name
         @start_line = start_line
         @start_column = start_column
         @text = text
       end
 
-      attr_reader :message, :input_name, :start_line, :start_column, :text
+      attr_reader :input_name, :start_line, :start_column, :text
+    end
+
+    # Class for parse errors.
+    # A ParseError indicates an error in the code being parsed.
+    # For other errors that the parser may raise, see ParserInternalError.
+    class ParseError < Parser::Error
+      def initialize message, input_name, start_line, start_column, text
+        super message, input_name, start_line, start_column, text
+      end
+    end
+
+    # Class for parser internal errors.
+    # A ParserInternalError indicates an error in the parser that is not
+    # flagged as an error in the code being parsed. Possible causes
+    # include I/O errors while reading code, as well as bugs in the
+    # parser.
+    # 
+    # The +cause+ attribute indicates the initial cause for the error.
+    # The other attributes of ParserInternalError are inherited from
+    # Parser::Error and indicate the input that was being
+    # processed when the error occurred.
+    class ParserInternalError < Parser::Error
+      def initialize cause, input_name, start_line, start_column, text
+        super cause.message, input_name, start_line, start_column, text
+        @cause = cause
+      end
+
+      attr_reader :cause
+    end
+
+    # Class wrapping multiple Parser::Errors.
+    class MultipleErrors < Parser::Error
+      def initialize errors
+        @errors = errors
+        super(nil, errors[0].input_name, errors[0].start_line,
+              errors[0].start_column, nil)
+      end
+
+      attr_reader :errors
+
+      def message
+        if @message == nil
+          msg = "Multiple errors:\n\n"
+          @errors.each do |error|
+            msg << error.input_name << ":" if error.input_name
+            msg << "#{error.start_line}: " << error.message
+            if error.text != nil
+              msg << "\n\n  #{error.text.gsub("\n", "\n  ")}"
+            end
+            msg << "\n"
+          end
+          @message = msg
+        end
+        @message
+      end
+
+      def text
+        if @text == nil
+          texts = @errors.map {|error| error.text}
+          @text = texts.join "\n"
+        end
+        @text
+      end
     end
 
     # Parses a top-level element.
@@ -79,66 +146,73 @@ module Voodoo
     #   # [:function, [:x, :y], [:let, :z, :add, :x, :y], [:return, :z]]
     #
     def parse_top_level
-      # Skip whitespace, comments, and empty lines
-      skip_to_next_top_level
+      wrap_exceptions do
+        @text = ''
+        # Skip whitespace, comments, and empty lines
+        skip_to_next_top_level
 
-      validate_top_level do
-        parse_top_level_nonvalidating
+        validate_top_level do
+          parse_top_level_nonvalidating
+        end
       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
-      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
+      wrap_exceptions do
+        body = []
+        errors = []
+        case kind
+        when :function
+          kind_text = 'function definition'
+        else
+          kind_text = kind.to_s
+        end
+        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
-              rescue Validator::ValidationError => e
-                parse_error e.message
+                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
-          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
+          rescue => e
+            # Got some kind of error. Still try to parse the rest of the body.
+            errors << e
           end
         end
-      end
 
-      if error != nil
-        raise error
-      end
+        # Raise error if we had just one.
+        # If we had more than one, raise a MultipleErrors instance.
+        if errors.length == 1
+          raise errors[0]
+        elsif errors.length > 1
+          raise MultipleErrors.new errors
+        end
 
-      body
+        body
+      end
     end
 
     # Parses an escape sequence.
@@ -146,101 +220,109 @@ module Voodoo
     # character (backslash). It decodes the escape sequence and returns
     # the result as a string.
     def parse_escape
-      result = nil
-      consume
-      case lookahead
-      when :eof
-        parse_error "Unexpected end of input in escape sequence", nil
-      when "\\", "\"", " "
-        result = lookahead
+      wrap_exceptions do
+        result = nil
         consume
-      when "n"
-        # \n is newline
-        consume
-        result = "\n"
-      when "r"
-        # \r is carriage return
-        consume
-        result = "\r"
-      when "x"
-        # \xXX is byte with hex value XX
-        code = @input.read 2
-        @column = @column + 2
-        consume
-        @text << code
-        result = [code].pack('H2')
-      when "\n"
-        # \<newline> is line continuation character
-        consume
-        # Skip indentation of next line
-        while lookahead =~ /\s/
+        case lookahead
+        when :eof
+          parse_error "Unexpected end of input in escape sequence", nil
+        when "\\", "\"", " "
+          result = lookahead
+          consume
+        when "n"
+          # \n is newline
+          consume
+          result = "\n"
+        when "r"
+          # \r is carriage return
+          consume
+          result = "\r"
+        when "x"
+          # \xXX is byte with hex value XX
+          code = @input.read 2
+          @column = @column + 2
+          consume
+          @text << code
+          result = [code].pack('H2')
+        when "\n"
+          # \<newline> is line continuation character
+          consume
+          # Skip indentation of next line
+          while lookahead =~ /\s/
+            consume
+          end
+          result = ''
+        else
+          # Default to just passing on next character
+          result = lookahead
           consume
         end
-        result = ''
-      else
-        # Default to just passing on next character
-        result = lookahead
-        consume
+        result
       end
-      result
     end
 
     # Parses a number.
     # This method should be called while the lookahead is the first
     # character of the number.
     def parse_number
-      text = lookahead
-      consume
-      while lookahead =~ /\d/
-        text << lookahead
+      wrap_exceptions do
+        text = lookahead
         consume
+        while lookahead =~ /\d/
+          text << lookahead
+          consume
+        end
+        text.to_i
       end
-      text.to_i
     end
 
     # Parses a string.
     # This method should be called while the lookahead is the opening
     # double quote.
     def parse_string
-      consume
-      result = ''
-      while true
-        case lookahead
-        when "\""
-          consume
-          break
-        when "\\"
-          result << parse_escape
-        else
-          result << lookahead
-          consume
+      wrap_exceptions do
+        consume
+        result = ''
+        while true
+          case lookahead
+          when "\""
+            consume
+            break
+          when "\\"
+            result << parse_escape
+          else
+            result << lookahead
+            consume
+          end
         end
+        result
       end
-      result
     end
 
     # Parses a symbol.
     # This method should be called while the lookahead is the first
     # character of the symbol name.
     def parse_symbol
-      name = ''
-      while true
-        case lookahead
-        when "\\"
-          name << parse_escape
-        when /\w|-/
-          name << lookahead
-          consume
-        when ':'
-          # Colon parsed as last character of the symbol name
-          name << lookahead
-          consume
-          break
-        else
-          break
+      wrap_exceptions do
+        name = ''
+        while true
+          case lookahead
+          when "\\"
+            name << parse_escape
+          when /\w|-/
+            name << lookahead
+            consume
+          when ':'
+            # Colon parsed as last character of the symbol name
+            name << lookahead
+            consume
+            break
+          else
+            break
+          end
         end
+        name.to_sym
       end
-      name.to_sym
     end
 
     #
@@ -252,13 +334,11 @@ module Voodoo
     # The character is appended to @text.
     def consume
       old = @lookahead
-      if old == 10
+      @lookahead = nil
+      if old == "\n"
         @line = @line.succ
         @column = 0
       end
-      @lookahead = @input.getc
-      @lookahead = :eof if @lookahead == nil
-      @column = @column.succ unless @lookahead == :eof
       @text << old
       old
     end
@@ -274,18 +354,18 @@ module Voodoo
     end
 
     # Returns the current lookahead character,
-    # or +nil+ when the end of the input has been reached.
+    # or +:eof+ 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
+        if @lookahead == nil
+          @lookahead = :eof
+        else
+          @lookahead = @lookahead.chr
+          @column = @column.succ
+        end
       end
+      @lookahead
     end
 
     # Parses a conditional statement
@@ -316,7 +396,7 @@ module Voodoo
       error.set_backtrace caller
 
       # If we are not at a new line, skip until the next line
-      while @column != 1 && lookahead != :eof
+      while @column > 1 && lookahead != :eof
         consume
       end
 
@@ -348,7 +428,6 @@ module Voodoo
           when "#"
             # Skip comment
             while lookahead != :eof && lookahead != "\n"
-              word << lookahead
               consume
             end
           else
@@ -364,6 +443,7 @@ module Voodoo
           # Add word to statement
           words << word
         end
+        words
       end
 
       # We have a line of input. Conditionals and function declarations
@@ -505,7 +585,9 @@ module Voodoo
         @start_line = @line
         @start_column = @column
         @text = ''
-        yield
+        wrap_exceptions do
+          yield
+        end
       ensure
         # Restore old values
         @start_line = old_line
@@ -514,5 +596,20 @@ module Voodoo
       end
     end
 
+    # Ensures that any exceptions that escape from block are instances of
+    # Parser::Error.
+    def wrap_exceptions &block
+      begin
+        yield
+      rescue Parser::Error
+        # Already an instance of Parser::Error; pass it through.
+        raise
+      rescue => e
+        # Some other error; wrap in ParserInternalError.
+        raise ParserInternalError.new(e, @input_name, @line,
+                                      @column, @text)
+      end
+    end
+    
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: voodoo
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Robbert Haarman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-14 00:00:00 -08:00
+date: 2012-01-29 00:00:00 -08:00
 default_executable: 
 dependencies: []