n65 0.5.0 → 1.0.0

data/lib/n65/parser.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 
 module N65
-
   require_relative 'instruction'
   require_relative 'directives/ines_header'
   require_relative 'directives/org'
@@ -15,71 +15,53 @@ module N65
   require_relative 'directives/exit_scope'
   require_relative 'directives/space'
 
-
-
-  ####
-  ##  This class determines what sort of line of code we
-  ##  are dealing with, parses one line, and returns an 
-  ##  object deriving from InstructionBase
+  # This class determines what sort of line of code we
+  # are dealing with, parses one line, and returns an
+  # object deriving from InstructionBase
   class Parser
-
-    ####  Custom Exceptions
     class CannotParse < StandardError; end
 
+    DIRECTIVES = [INESHeader, Org, Segment, IncBin, Inc, DW, Bytes, ASCII, EnterScope, ExitScope, Space].freeze
 
-    Directives = [INESHeader, Org, Segment, IncBin, Inc, DW, Bytes, ASCII, EnterScope, ExitScope, Space]
-
-    ####
-    ##  Parses a line of program source into an object
-    ##  deriving from base class InstructionBase
+    # Parses a line of program source into an object
+    # deriving from base class InstructionBase
     def self.parse(line)
       sanitized = sanitize_line(line)
       return nil if sanitized.empty?
 
-      ##  First check to see if we have a label.
+      # First check to see if we have a label.
       label = Label.parse(sanitized)
-      unless label.nil?
-        return label
-      end
+      return label unless label.nil?
 
-      ##  Now check if we have a directive
+      # Now check if we have a directive
       directive = parse_directive(sanitized)
-      unless directive.nil?
-        return directive
-      end
+      return directive unless directive.nil?
 
-      ##  Now, surely it is an asm instruction?
+      # Now, surely it is an asm instruction?
       instruction = Instruction.parse(sanitized)
-      unless instruction.nil?
-        return instruction
-      end
+      return instruction unless instruction.nil?
 
-      ##  Guess not, we have no idea
-      fail(CannotParse, sanitized)
+      # Guess not, we have no idea
+      raise(CannotParse, sanitized)
     end
 
-
-    private
-    ####
-    ##  Sanitize one line of program source
+    # Sanitize one line of program source
     def self.sanitize_line(line)
-      code = line.split(';').first || ""
+      code = line.split(';').first || ''
       code.strip.chomp
     end
+    private_class_method :sanitize_line
 
-
-    ####
     ##  Try to Parse a directive
     def self.parse_directive(line)
       if line.start_with?('.')
-        Directives.each do |directive|
+        DIRECTIVES.each do |directive|
           object = directive.parse(line)
           return object unless object.nil?
         end
       end
       nil
     end
-
+    private_class_method :parse_directive
   end
-
 end

data/lib/n65/regexes.rb

@@ -1,33 +1,32 @@
-
+# frozen_string_literal: true
 
 module N65
-
-  ####
-  ##  All the regexes used to parse in one module
+  # All the regexes used to parse in one module
   module Regexes
-    ##  Mnemonics 
-    Mnemonic  = '([A-Za-z]{3})'
-    Branches  = '(BPL|BMI|BVC|BVS|BCC|BCS|BNE|BEQ|bpl|bmi|bvc|bvs|bcc|bcs|bne|beq)'
+    # rubocop:disable Naming/ConstantName
+    # Mnemonics
+    Mnemonic   = '([A-Za-z]{3})'
+    Branches   = '(BPL|BMI|BVC|BVS|BCC|BCS|BNE|BEQ|bpl|bmi|bvc|bvs|bcc|bcs|bne|beq)'
 
-    ##  Numeric Literals
-    Hex8      = '\$([A-Fa-f0-9]{1,2})'
-    Hex16     = '\$([A-Fa-f0-9]{3,4})'
+    # Numeric Literals
+    Hex8       = '\$([A-Fa-f0-9]{1,2})'
+    Hex16      = '\$([A-Fa-f0-9]{3,4})'
 
-    Bin8      = '%([01]{1,8})'
-    Bin16     = '%([01]{9,16})'
+    Bin8       = '%([01]{1,8})'
+    Bin16      = '%([01]{9,16})'
 
-    Num8      = Regexp.union(Regexp.new(Hex8), Regexp.new(Bin8)).to_s
-    Num16     = Regexp.union(Regexp.new(Hex16),Regexp.new(Bin16)).to_s
+    Num8       = Regexp.union(Regexp.new(Hex8), Regexp.new(Bin8)).to_s
+    Num16      = Regexp.union(Regexp.new(Hex16), Regexp.new(Bin16)).to_s
 
-    Immediate = "\##{Num8}"
+    Immediate  = "\##{Num8}"
 
-    ##  Symbols, must begin with a letter, and supports dot syntax
-    Sym       = '([a-zA-Z][a-zA-Z\d_\.]*)'
+    # Symbols, must begin with a letter, and supports dot syntax
+    Sym        = '([a-zA-Z][a-zA-Z\d_\.]*(?:[\+\-\*\/]\d+)*)'
 
+    # The X or Y register
+    XReg       = '[Xx]'
+    YReg       = '[Yy]'
 
-    ##  The X or Y register
-    XReg      = '[Xx]'
-    YReg      = '[Yy]'
+    # rubocop:enable Naming/ConstantName
   end
-
 end

data/lib/n65/symbol_table.rb

@@ -1,131 +1,107 @@
+# frozen_string_literal: true
 
 module N65
-
   class SymbolTable
     attr_accessor :scope_stack
 
-    #####  Custom Exceptions
     class InvalidScope < StandardError; end
     class UndefinedSymbol < StandardError; end
     class CantExitScope < StandardError; end
 
-
-    ####
-    ##  Initialize a symbol table that begins in global scope
+    # Initialize a symbol table that begins in global scope
     def initialize
       @symbols = {
-        :global => {}
+        global: {}
       }
       @anonymous_scope_number = 0
       @scope_stack = [:global]
+      @subroutine_cycles = {}
     end
 
+    # Add a running cycle count to current top level scopes (ie subroutines)
+    def add_cycles(cycles)
+      cycles ||= 0
+      top_level_subroutine = @scope_stack[1]
+      return if top_level_subroutine.nil?
+
+      @subroutine_cycles[top_level_subroutine] ||= 0
+      @subroutine_cycles[top_level_subroutine] += cycles
+    end
 
-    ####
-    ##  Define a new scope, which can be anonymous or named
-    ##  and switch into that scope
+    # Define a new scope, which can be anonymous or named
+    # and switch into that scope
     def enter_scope(name = nil)
-      name = generate_name if name.nil? 
+      name = generate_name if name.nil?
       name = name.to_sym
       scope = current_scope
-      if scope.has_key?(name)
-        #path_string = generate_scope_path(path_ary)
-        fail(InvalidScope, "Scope: #{name} already exists")
-      end
+      raise(InvalidScope, "Scope: #{name} already exists") if scope.key?(name)
+
       scope[name] = {}
       @scope_stack.push(name)
     end
 
-
-    ####
-    ##  Exit the current scope
+    # Exit the current scope
     def exit_scope
-      if @scope_stack.size == 1
-        fail(CantExitScope, "You cannot exit global scope")
-      end
+      raise(CantExitScope, 'You cannot exit global scope') if @scope_stack.size == 1
+
       @scope_stack.pop
     end
 
-
-    ####
-    ##  Define a symbol in the current scope
+    # Define a symbol in the current scope
     def define_symbol(symbol, value)
       scope = current_scope
       scope[symbol.to_sym] = value
     end
 
+    # Separate arithmetic from symbol
+    def find_arithmetic(name)
+      last_name = name.split('.').last
+      md = last_name.match(%r{([+\-*/])(\d+)$})
+      f = ->(v) { v }
 
-=begin
-    ####
-    ##  Resolve symbol to a value, for example:
-    ##  scope1.scope2.variable
-    ##  It is not nessessary to specify the root scope :global
-    ##  You can just address anything by name in the current scope
-    ##  To go backwards in scope you need to write the full path
-    ##  like global.sprite.x or whatever
-    def resolve_symbol_old(name)
-
-      value = if name.include?('.')
-        path_ary = name.split('.').map(&:to_sym)
-        symbol = path_ary.pop
-        path_ary.shift if path_ary.first == :global
-        scope = retreive_scope(path_ary)
-        ##  We also try to look up the address associated with the scope
-        root = "-#{symbol}".to_sym
-        v = scope[symbol]
-        v.kind_of?(Hash) ? v[root] : v
-      else
-        root = "-#{name}".to_sym
-        scope = current_scope
-        ##  We also try to look up the address associated with the scope
-        v = scope[name.to_sym] || scope[root]
-        v.kind_of?(Hash) ? v[root] : v
+      unless md.nil?
+        full_match, operator, argument = md.to_a
+        name = name.gsub(full_match, '')
+        f = ->(value) { value.send(operator.to_sym, argument.to_i) }
       end
 
-      if value.nil?
-        fail(UndefinedSymbol, name)
-      end
-      value
+      [name, f]
     end
-=end
-
 
-    ####
-    ##  
+    # Resolve a symbol to its value
     def resolve_symbol(name)
+      name, arithmetic = find_arithmetic(name)
+
       method = name.include?('.') ? :resolve_symbol_dot_syntax : :resolve_symbol_scoped
-      value = self.send(method, name)
+      value = send(method, name)
+      value = arithmetic.call(value)
+      raise(UndefinedSymbol, name) if value.nil?
 
-      fail(UndefinedSymbol, name) if value.nil?
       value
     end
 
-
-    ####
-    ##  Resolve symbol by working backwards through each
-    ##  containing scope.  Similarly named scopes shadow outer scopes
+    # Resolve symbol by working backwards through each
+    # containing scope.  Similarly named scopes shadow outer scopes
     def resolve_symbol_scoped(name)
       root = "-#{name}".to_sym
       stack = @scope_stack.dup
       loop do
         scope = retreive_scope(stack)
 
-        ##  We see if there is a key either under this name, or root
+        # We see if there is a key either under this name, or root
         v = scope[name.to_sym] || scope[root]
-        v = v.kind_of?(Hash) ? v[root] : v
+        v = v.is_a?(Hash) ? v[root] : v
 
         return v unless v.nil?
 
-        ##  Pop the stack so we can decend to the parent scope, if any
+        # Pop the stack so we can decend to the parent scope, if any
         stack.pop
         return nil if stack.empty?
       end
     end
 
-
-    ####
-    ##  Dot syntax means to check an absolute path to the symbol
-    ##  :global is ignored if it is provided as part of the path
+    # Dot syntax means to check an absolute path to the symbol
+    # :global is ignored if it is provided as part of the path
     def resolve_symbol_dot_syntax(name)
       path_ary = name.split('.').map(&:to_sym)
       symbol = path_ary.pop
@@ -134,33 +110,32 @@ module N65
 
       scope = retreive_scope(path_ary)
 
-      ##  We see if there is a key either under this name, or root
+      # We see if there is a key either under this name, or root
       v = scope[symbol]
-      v.kind_of?(Hash) ? v[root] : v
+      v.is_a?(Hash) ? v[root] : v
     end
 
-
-    ####
-    ##  Export the symbol table as YAML
+    # Export the symbol table as YAML
     def export_to_yaml
       @symbols.to_yaml.gsub(/(\d+)$/) do |match|
         integer = match.to_i
-        sprintf("0x%.4X", integer)
+        format('0x%.4X', integer)
       end
     end
 
+    # Export a cycle count for top level subroutines
+    def export_cycle_count_yaml
+      @subroutine_cycles.to_yaml
+    end
 
     private
 
-    ####
-    ##  A bit more clearly states to get the current scope
+    # A bit more clearly states to get the current scope
     def current_scope
       retreive_scope
     end
 
-
-    ####
-    ##  Retrieve a reference to a scope, current scope by default
+    # Retrieve a reference to a scope, current scope by default
     def retreive_scope(path_ary = @scope_stack)
       path_ary = path_ary.dup
       path_ary.unshift(:global) unless path_ary.first == :global
@@ -171,28 +146,22 @@ module N65
         if new_scope.nil?
           path_string = generate_scope_path(path_ary)
           message = "Resolving scope: #{path_string} failed at #{path_component}"
-          fail(InvalidScope, message) if new_scope.nil?
+          raise(InvalidScope, message) if new_scope.nil?
         end
 
         new_scope
       end
     end
 
-
-    ####
-    ##  Generate a scope path from an array
+    # Generate a scope path from an array
     def generate_scope_path(path_ary)
       path_ary.join('.')
     end
 
-
-    ####
-    ##  Generate an anonymous scope name
+    # Generate an anonymous scope name
     def generate_name
       @anonymous_scope_number += 1
       "anonymous_#{@anonymous_scope_number}"
     end
-
   end
-
 end

data/lib/n65/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module N65
-  VERSION = "0.5.0"
+  VERSION ||= '1.0.0'
 end