voodoo 1.0.2 → 1.1.1

data/lib/voodoo/parser.rb

@@ -20,6 +20,10 @@ module Voodoo
   #     end
   #   end
   class Parser
+    NUMBER_STARTER = /\d|-/
+    STRING_STARTER = '"'
+    SYMBOL_STARTER = /[[:alpha:]]|\\/
+    
     # Creates a parser using the specified object as input.
     # The input object must support a method +getc+, which must
     # return the next character of the input, or +nil+ to indicate
@@ -157,7 +161,9 @@ module Voodoo
       end
     end
 
-    # Parses a body for a function or a conditional
+    # Parses statements up to "end X". _kind_ should indicate the type
+    # of body being parsed: :block, :conditional, :function, or :group.
+    # Returns an array of statements.
     def parse_body kind
       wrap_exceptions do
         body = []
@@ -168,6 +174,9 @@ module Voodoo
         else
           kind_text = kind.to_s
         end
+        # Groups are allowed to contain top-level statements.
+        # All other kinds aren't.
+        top_level = kind == :group
         done = false
         until done
           begin
@@ -186,14 +195,22 @@ module Voodoo
                 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
+                  if top_level
+                    Validator.validate_top_level statement
+                  else
+                    Validator.validate_statement statement
+                  end
                   body << statement
                 rescue Validator::ValidationError => e
-                  parse_error e.message
+                  magic_word = statement[0]
+                  if !top_level &&
+                      Validator::TOP_LEVELS.member?(magic_word) &&
+                      !Validator::STATEMENTS.member?(magic_word)
+                    parse_error "#{magic_word} is only allowed at top-level"
+                  else
+                    parse_error e.message
+                  end
                 end
               end
             end
@@ -348,7 +365,7 @@ module Voodoo
       symbol.to_s[-1] == ?:
     end
 
-    # Tests if a symbol is a conditional starter
+    # Tests if a symbol is a conditional starter.
     def is_conditional? symbol
       [:ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne].member? symbol
     end
@@ -368,7 +385,7 @@ module Voodoo
       @lookahead
     end
 
-    # Parses a conditional statement
+    # Parses a conditional statement.
     def parse_conditional1 condition, operands
       # Parse first clause and condition for next clause
       consequent, next_condition = split_if_clause parse_body(:conditional)
@@ -386,7 +403,7 @@ module Voodoo
       [condition, operands, consequent, alternative]
     end
 
-    # Raises a ParseError at the current input position
+    # 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,
@@ -404,7 +421,7 @@ module Voodoo
       raise error
     end
 
-    # Parses a top-level directive without validating it
+    # Parses a top-level incantation without validating it.
     def parse_top_level_nonvalidating
       # Skip whitespace, comments, and empty lines
       skip_to_next_top_level
@@ -458,16 +475,16 @@ module Voodoo
         [: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
+      elsif words[0] == :block || words[0] == :group
+        body = parse_body words[0]
+        [words[0]] + body
       else
         # Statement or data declaration; simply return it
         words
       end
     end
 
-    # Skips whitespace, newlines, and comments before a top-level directive
+    # Skips whitespace, newlines, and comments before a top-level incantation.
     def skip_to_next_top_level
       while true
         case lookahead
@@ -527,14 +544,14 @@ module Voodoo
       case lookahead
       when :eof
         nil
-      when /\d|-/
+      when NUMBER_STARTER
         # Digit; parse number
         parse_number
-      when /\w|\\/
+      when SYMBOL_STARTER
         # Letter, underscore, or backslash; parse symbol
         # Note: \w matches digits, too, so keep this case after \d
        parse_symbol
-      when "\""
+      when STRING_STARTER
         # Double quote; parse string
         parse_string
       when '@'
@@ -542,23 +559,30 @@ module Voodoo
         # '@' must be followed by a number or symbol.
         consume
         case lookahead
-        when /\d|-/
+        when NUMBER_STARTER
           expr = parse_number
-        when /\w|\\/
+        when SYMBOL_STARTER
           expr = parse_symbol
         else
           parse_error "Invalid character (#{lookahead}) " +
             "in at-expression; expecting number or symbol"
         end
         [:'@', expr]
+      when '%'
+	consume
+	# Must be followed by a symbol.
+	if lookahead !~ SYMBOL_STARTER
+          parse_error "'%' must be followed by a symbol"
+	end
+	[:'%', parse_symbol]
       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.
+    # Evaluates _block_ and checks that the result is a valid top-level
+    # incantation.
     def validate_top_level &block
       with_position do
         result = yield
@@ -573,7 +597,7 @@ module Voodoo
       end
     end
 
-    # Evaluate block, keeping track of @start_line, @start_column
+    # Evaluates 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

data/lib/voodoo/validator.rb

@@ -1,25 +1,31 @@
 module Voodoo
   # Functionality for validating Voodoo code.
+  #
+  # See validate_top_level, validate_statement, and validate_expression.
   module Validator
 
-    # Expressions that take two arguments
+    # Expressions that take two parameters.
     BINOPS = [:add, :and, :asr, :bsr, :div, :'get-byte', :'get-word',
               :mod, :mul, :or, :rol, :ror, :shl, :shr, :sub, :xor]
-    # Expressions that take zero or more parameters
+    # Expressions that take a single parameter.
+    UNOPS =  [:'auto-bytes', :'auto-words', :not]
+    # Expressions that take zero or more parameters.
     VARARG_EXPRS = [:call, :'tail-call']
-    # Symbols that may occur as the first word of an expression
-    EXPRS = BINOPS + VARARG_EXPRS + [:not]
+    # Symbols that may occur as the first word of an expression.
+    EXPRS = BINOPS + UNOPS + VARARG_EXPRS
 
-    # Symbols that are a valid start of a statement
-    STATEMENTS = [:block, :call, :goto,
-                  :ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne,
-                  :label, :let, :return, :set,
-                  :'set-byte', :'set-word', :'tail-call']
+    # Symbols that are a valid start of a statement.
+    STATEMENTS = [:byte, :block, :call, :goto, :ifeq, :ifge,
+                  :ifgt, :ifle, :iflt, :ifne, :label, :let, :return,
+                  :'restore-frame', :'restore-locals', :'save-frame',
+                  :'save-frame-and-locals', :'save-locals', :set,
+                  :'set-byte', :'set-word', :string, :'tail-call', :word]
 
-    # Symbols that are valid at top-level
-    TOP_LEVELS = [:align, :byte, :export, :function, :import,
-                  :section, :string, :word] + STATEMENTS
+    # Symbols that are valid at top-level.
+    TOP_LEVELS = [:align, :export, :function, :group, :import, :section] +
+      STATEMENTS
 
+    # Maps indices 0, 1, 2 to English words.
     NTH = ['First', 'Second', 'Third']
 
     module_function
@@ -31,13 +37,18 @@ module Voodoo
       if int_or_symbol_or_at? code
         true
       elsif code.respond_to? :[]
-        if BINOPS.member? code[0]
+        op = code[0]
+        if BINOPS.member? op
           # binop should have 2 parameters, both of them atomic values
           assert_n_params code, 2
           assert_params_are_values code
+        elsif UNOPS.member? op
+            # should have a single, atomic parameter
+            assert_n_params code, 1
+            assert_params_are_values code
         else
-          # code[0] is not a binop
-          case code[0]
+          # op is not a unary or binary operator
+          case op
           when :call, :'tail-call'
             # call should have at least 1 parameter
             # and all parameters should be atomic values
@@ -47,10 +58,6 @@ module Voodoo
             # Should have exactly 2 parameters, both of which should be values.
             assert_n_params code, 2
             assert_params_are_values code
-          when :not
-            # should have a single, atomic parameter
-            assert_n_params code, 1
-            assert_params_are_values code
           else
             raise ValidationError.new("#{code[0].inspect}" +
                                       " cannot start an expression",
@@ -74,6 +81,16 @@ module Voodoo
           code[1..-1].each {|stmt| validate_statement stmt}
           true
 
+        when :byte, :word
+          # Should have a single integer or symbol parameter
+          if code.length != 2 || !int_or_symbol?(code[1])
+            raise ValidationError.new("#{code[0]} requires a single" +
+                                      " parameter that is either an " +
+                                      " integer or a symbol", code)
+          else
+            true
+          end
+
         when :call, :'tail-call'
           validate_expression code
 
@@ -133,12 +150,12 @@ module Voodoo
             true
           end
 
-        when :let, :set
+        when :let
           # should have at least 2 parameters
           if code.length < 3
             raise ValidationError.new("#{code[0]} requires a symbol" +
                                       " and an expression", code)
-          elsif code[1].kind_of? ::Symbol
+          elsif symbol? code[1]
             # After the symbol, there should be an expression
             expr = code[2..-1]
             if expr.length == 1
@@ -151,6 +168,25 @@ module Voodoo
                                         " a symbol", code)
           end
 
+        when :set
+          # should have at least 2 parameters
+          if code.length < 3
+            raise ValidationError.new(
+              "#{code[0]} requires a symbol or at-expression" +
+              " followed by an expression", code)
+          elsif symbol_or_at? code[1]
+            # After the symbol/at-expr, there should be an expression
+            expr = code[2..-1]
+            if expr.length == 1
+              validate_expression expr[0]
+            else
+              validate_expression expr
+            end
+          else
+            raise ValidationError.new("First parameter to #{code[0]} should be" +
+                                        " a symbol or an at-expression", code)
+          end
+
         when :return
           # Should either have no parameters, or a single expression as
           # a parameter.
@@ -169,9 +205,33 @@ module Voodoo
           assert_n_params code, 3
           assert_params_are_values code
 
+	when :'restore-frame', :'save-frame'
+	  # Should have exactly 1 parameter.
+	  assert_n_params code, 1
+	  assert_params_are_values code
+
+	when :'restore-locals', :'save-frame-and-locals', :'save-locals'
+	  # Should have 1 or more parameters.
+	  assert_at_least_n_params code, 1
+	  assert_params_are_values code
+
+        when :string
+          # Should have a single string parameter
+          if code.length != 2 || !code[1].kind_of?(::String)
+            raise ValidationError.new("string requires a single string" +
+                                      " as a parameter", code)
+          else
+            true
+          end
+
         else
-          raise ValidationError.new("Not a valid statement: #{code.inspect}",
-                                    code)
+          if TOP_LEVELS.member?(code[0]) && !STATEMENTS.member?(code[0])
+            raise ValidationError.new("#{code[0]} is only valid at top-level", code)
+          else
+
+            raise ValidationError.new("Not a valid statement: #{code.inspect}",
+                                      code)
+          end
         end
 
       rescue ValidationError
@@ -190,9 +250,9 @@ module Voodoo
       end
     end
 
-    # Validates a top-level directive.
-    # Returns true if the directive is valid.
-    # Raises ValidationError if the directive is not valid.
+    # Validates a top-level incantation.
+    # Returns true if the incantation is valid.
+    # Raises ValidationError if the incantation is not valid.
     def validate_top_level code
       begin
         case code[0]
@@ -207,16 +267,6 @@ module Voodoo
                                       code)
           end
 
-        when :byte, :word
-          # Should have a single integer or symbol parameter
-          if code.length != 2 || !int_or_symbol?(code[1])
-            raise ValidationError.new("#{code[0]} requires a single" +
-                                      " parameter that is either an " +
-                                      " integer or a symbol", code)
-          else
-            true
-          end
-
         when :export, :import
           # Should have at least 1 parameter, and all parameters should
           # be symbols.
@@ -248,15 +298,12 @@ module Voodoo
             end
           end
 
-          # Verify statements
-          code[2..-1].each do |stmt|
-            if stmt.respond_to?(:[]) && stmt[0] == :function
-              raise ValidationError.new("Function definitions are only " +
-                                        "valid at top-level", stmt)
-            else
-              validate_statement stmt
-            end
-          end
+          # Verify body.
+          code[2..-1].each { |stmt| validate_statement stmt }
+
+        when :group
+          # Verify body.
+          code[1..-1].each { |stmt| validate_top_level stmt }
 
         when :section
 
@@ -273,25 +320,16 @@ module Voodoo
             end
 
           else
-            raise ValidationError.new("section directive should have only" +
+            raise ValidationError.new("section incantation should have only" +
                                       " a single parameter",
                                       code);
           end
 
-        when :string
-          # Should have a single string parameter
-          if code.length != 2 || !code[1].kind_of?(::String)
-            raise ValidationError.new("string requires a single string" +
-                                      " as a parameter", code)
-          else
-            true
-          end
-
         else
           if STATEMENTS.member? code[0]
             validate_statement code
           else
-            raise ValidationError.new("Directive #{code[0]}" +
+            raise ValidationError.new("Incantation #{code[0]}" +
                                       " not valid at top-level",
                                       code)
           end
@@ -377,14 +415,34 @@ module Voodoo
       true
     end
 
+    def at_expr? x
+      x.respond_to?(:length) && x.length == 2 && x[0] == :'@' &&
+        int_or_symbol?(x[1])
+    end
+
+    def int? x
+      x.kind_of?(::Integer) || substitution?(x)
+    end
+    
     def int_or_symbol? x
-      x.kind_of?(::Symbol) || x.kind_of?(::Integer)
+      x.kind_of?(::Symbol) || int?(x)
     end
 
     def int_or_symbol_or_at? x
-      int_or_symbol?(x) ||
-        (x.respond_to?(:length) && x.length == 2 && x[0] == :'@' &&
-         int_or_symbol?(x[1]))
+      int_or_symbol?(x) || at_expr?(x)
+    end
+
+    def substitution? x
+      x.respond_to?(:length) && x.length == 2 && x[0] == :'%' &&
+        symbol?(x[1])
+    end
+
+    def symbol? x
+      x.kind_of? ::Symbol
+    end
+
+    def symbol_or_at? x
+      symbol?(x) || at_expr?(x)
     end
 
   end