ucisc 0.1.3 → 0.1.4

data/exe/ucisc

@@ -6,14 +6,17 @@ require "byebug"
 
 if ARGV.length < 1
   puts "Usage:"
-  puts "  ucisc <file_name>"
+  puts "  ucisc <file_name> [<file_name> ...]"
   exit(0)
 end
 
-file_name = ARGV.first
-puts "Reading #{file_name}"
-compiler = MicroCisc.load(file_name)
-puts "Running program with #{compiler.serialize.size} words"
+file_names = ARGV.reject { |name| name.start_with?("-") }
+puts "Reading #{file_names.join(" ")}"
+compiler = MicroCisc.load(file_names)
+
+instructions = compiler.command_count
+size = compiler.serialize.size
+puts "Running program with #{instructions} instructions compiled to #{size} words"
 
 begin
   MicroCisc.run(compiler.serialize)

data/lib/micro_cisc.rb

@@ -13,25 +13,48 @@ require "micro_cisc/vm/device"
 require "micro_cisc/vm/processor"
 require "micro_cisc/vm/term_device"
 require "micro_cisc/vm/empty_device"
+require "micro_cisc/vm/color_lcd_display"
 
 module MicroCisc
   class Error < StandardError; end
 
-  def self.load(file_name)
-    text = File.read(file_name)
+  def self.load(file_names)
+    text = ""
+    file_names.each do |file_name|
+      text += File.read(file_name)
+    end
     MicroCisc::Compile::Compiler.new(text)
   end
 
   def self.run(data)
-    rom = Array.new(256).map { 0 }
-    rom[0...data.size] = data
+    blocks = data.size / 256 + 1
+    rom_blocks = []
+    (0...blocks).each do |block|
+      rom = Array.new(256).map { 0 }
+      size = data.size - block * 256
+      size = 256 if size > 256
+      rom[0...size] = data[(block * 256)...((block + 1) * 256)]
+      rom_blocks << rom
+    end
     terminal = MicroCisc::Vm::TermDevice.new(5)
-    terminal.host_device = 1
-    devices = Array.new(16).map { MicroCisc::Vm::EmptyDevice.new }
+    screen = MicroCisc::Vm::EmptyDevice.new
+    init_screen = ARGV.include?('-s')
+    if(init_screen)
+      screen = MicroCisc::Vm::ColorLcdDisplay.new(
+        6, # Device ID
+        40, # 10k words of memory (40 blocks)
+        128, # screen pixel width
+        72,  # screen pixel height
+        MicroCisc::Vm::ColorLcdDisplay::COLOR_MODE_12BIT
+      )
+    end
+    devices = Array.new(17).map { MicroCisc::Vm::EmptyDevice.new }
     devices[15] = terminal # first banked device
-    processor = MicroCisc::Vm::Processor.new(1, 256, [rom])
+    devices[16] = screen
+    processor = MicroCisc::Vm::Processor.new(1, 256, rom_blocks)
     processor.devices = devices
     processor.start(ARGV.include?('-d'))
+    screen.join if(init_screen)
     processor
   end
 

data/lib/micro_cisc/compile/compiler.rb

@@ -1,8 +1,11 @@
 module MicroCisc
   module Compile
     class Compiler
+      attr_reader :command_count
+
       def initialize(text)
         @text = text
+        @command_count = 0
         parse
       end
 
@@ -11,17 +14,21 @@ module MicroCisc
         @instructions = []
         address = 0
         @labels = {}
-        @sugar = {}
+        @indexed_vars = {}
+        @equivalents = {}
         errors = []
         lgen = MicroCisc::Compile::LabelGenerator.new
+        @command_count = 0
         @text.each_line do |line|
           begin
-            statement = MicroCisc::Compile::Statement.new(lgen, line, @sugar)
+            statement = MicroCisc::Compile::Statement.new(lgen, line, @indexed_vars, @equivalents)
+            command = false
             statement.parse.each do |instruction|
               if instruction.label?
                 @labels[instruction.label] = address
               elsif instruction.instruction?
                 @instructions << [line_number, instruction]
+                command = true
                 address += 1
               elsif instruction.data?
                 @instructions += instruction.data.map { |d| [line_number, d] }
@@ -38,6 +45,7 @@ module MicroCisc
                 address += word_counts.sum
               end
             end
+            @command_count += 1 if command
           rescue ArgumentError => e
             MicroCisc.logger.error("Error on line #{line_number}: #{e.message}\n  #{line}")
             errors << [line_number, e, line]

data/lib/micro_cisc/compile/instruction.rb

@@ -1,19 +1,20 @@
 module MicroCisc
   module Compile
     class Instruction
-      attr_reader :label, :instruction, :data, :imm, :sign, :dir, :reg, :dest, :original, :minimal
+      COMPONENT_WITH_QUOTES_REGEX = /(?<component>[^\s"']+|"((\\"|[^"])*)")/
+      attr_reader :label, :operation, :data, :immediates, :sign, :dir, :src, :dest, :original, :minimal, :inc
 
-      def initialize(label_generator, minimal, original, sugar)
+      def initialize(label_generator, minimal, original, statement)
         @label_generator = label_generator
         @original = original
         @label = nil
         @operation = nil
         @sign = nil
         @dir = nil
-        @imm = nil
+        @immediates = []
         @src = nil
         @dest = nil
-        @sugar = sugar
+        @statement = statement
         @data = nil
         @inc = nil
         @eff = nil
@@ -38,7 +39,7 @@ module MicroCisc
       end
 
       def parse_ucisc(minimal_instruction)
-        @components = minimal_instruction.split(/\s/)
+        @components = minimal_instruction.scan(COMPONENT_WITH_QUOTES_REGEX).flatten
 
         return if @components.empty?
 
@@ -57,6 +58,28 @@ module MicroCisc
 
         if @components.first == '%'
           @components.shift
+          @components = @components.map do |component|
+            if component =~ /"(\\"|[^"])*"/
+              # Remove surrounding quotes
+              component = component[1...(component.length - 1)]
+              component = component.gsub("\\n","\n")
+              component = component.gsub("\\\"","\"")
+              hex = []
+              offset = 0
+              while(offset < component.length)
+                pair = component[offset...(offset + 2)]
+                pair = pair.bytes
+                pair << 0 if pair.length < 2
+                word = pair.pack("C*").unpack("S>").last
+                hex_word = "%04X" % word
+                hex << hex_word
+                offset += 2
+              end
+              component = ["%04X" % component.length] + hex
+            else
+              component
+            end
+          end.flatten
           @data = @components.map do |component|
             if match = /(?<name>[^\s]+)\.(?<type>imm|disp)/.match(component)
               [match['name'], match['type']]
@@ -98,7 +121,7 @@ module MicroCisc
         raise ArgumentError, "Duplicate #{component.last} value" if current
         code = component.first
         unless code >= 0 && code < 16
-          raise ArgumentError, "Value of #{component.last} must be between 0x0 and 0xF instead of #{component.first.to_s(16).upcase}"
+          raise ArgumentError, "Value of #{component.last} must be between 0x0 and 0xF instead of 0x#{component.first.to_s(16).upcase}"
         end
         component.first
       end
@@ -135,8 +158,10 @@ module MicroCisc
         while components.size > 0
           to_parse = components.shift
           if(to_parse.start_with?('$') || to_parse.start_with?('&'))
-            raise ArgumentError, "Missing ref #{to_parse}" unless @sugar[to_parse]
-            to_parse = @sugar[to_parse]
+            raise ArgumentError, "Missing ref #{to_parse}" unless @statement.get_var(to_parse)
+            to_parse = @statement.get_var(to_parse)
+            components = to_parse.split(/\s/) + components
+            to_parse = components.shift
           end
           parsed = parse_component(to_parse)
           if ['val', 'reg', 'mem'].include?(parsed.last)
@@ -198,7 +223,9 @@ module MicroCisc
           end
         end
 
-        if @immediates.last != 0 && (!@source_is_mem || !@dest_is_mem)
+        if @immediates.last != 0 && @operation == 'alu'
+          raise ArgumentError, "Destination immediate is not allowed for compute instructions"
+        elsif @immediates.last != 0 && (!@source_is_mem || !@dest_is_mem)
           raise ArgumentError, "Destination immediate is only allowed when both arguments are mem args"
         end
 
@@ -208,18 +235,18 @@ module MicroCisc
 
       def validate_immediate(value, index)
         width = @bit_width
-        width = width / 2 if @source_is_mem && @dest_is_mem
+        width = width / 2 if @operation == 'copy' && @source_is_mem && @dest_is_mem
         if index == 0 && @source_is_mem || index == 1 && @dest_is_mem
           min = 0
-          max = (2 << @bit_width) - 1
+          max = (1 << width) - 1
         else
-          magnitude = 1 << (@bit_width - 1)
+          magnitude = 1 << (width - 1)
           min = magnitude * -1
           max = magnitude - 1
         end
         if (value < min || value > max)
           signed = @source_is_mem ? 'unsigned' : 'signed'
-          raise ArgumentError, "Immediate max bits is #{@bit_width} #{signed}; value must be between #{min} and #{max} instead of #{value}"
+          raise ArgumentError, "Immediate max bits is #{width} #{signed}; value must be between #{min} and #{max} instead of #{value}"
         end
       end
 

data/lib/micro_cisc/compile/statement.rb

@@ -1,16 +1,17 @@
 module MicroCisc
   module Compile
     class Statement
-      SUGAR_REGEX = /(?<name>(\$|&)[^\s\[\]]+)\s+(?<op>as|=)\s+(?<param>.+)/
+      SUGAR_REGEX = /(?<names>(\$|&)[^\s\[\]]+(\s*,\s*(\$|&)[^\s\[\]]+)*)\s+(?<op>as|=)\s+(?<param>.+)/
       FUNCTION_REGEX = /(?<stack>[^\s\[\]]+)\s*(\[(?<words>[0-9]+)\]){0,1}\s+<=\s+(?<label>[a-zA-Z_][a-zA-Z0-9_\-@$!%]*)\s*\(\s*(?<args>[^)]*)/
-      IMM_REGEX = / (0x){0,1}(?<imm_val>[0-9A-Fa-f])\.imm/
+      IMM_REGEX = / (?<imm_val>-{0,1}(0x){0,1}[0-9A-Fa-f])\.imm/
       attr_reader :original, :minimal
 
-      def initialize(label_generator, statement, sugar)
+      def initialize(label_generator, statement, indexed_vars, equivalents)
         @label_generator = label_generator
         @original = statement
         @minimal = filter_comments(statement)
-        @sugar = sugar
+        @indexed_vars = indexed_vars
+        @equivalents = equivalents
       end
 
       def filter_comments(instruction)
@@ -24,44 +25,124 @@ module MicroCisc
         instruction.gsub(/\s+/, ' ')
       end
 
-      def create_variable(name, arg)
-        if arg.end_with?("mem") || arg.end_with?("reg")
+      def normalize(arg, delta)
+        imm_matches = arg.scan(IMM_REGEX).flatten
+        imm_val = imm_matches.map(&:to_i).sum + delta
+        arg = arg.gsub(IMM_REGEX, '').strip
+        [arg, imm_val]
+      end
+
+      def create_variable(name, arg, delta)
+        unless arg.include?("mem") || arg.include?("reg")
+          raise ArgumentError, "Indexed variable reference is not allowed for non-register arguments, use 'as' instead"
+        end
+
+        arg = normalize(arg, delta)
+        imm_val = arg.last
+        # remove mem/reg part
+        arg_num = arg.first[0..-4]
+        name = name[1..-1]
+
+        mem_name = "$#{name}"
+        ref_name = "&#{name}"
+        @equivalents.delete(mem_name)
+        @equivalents.delete(ref_name)
+        @indexed_vars[mem_name] = ["#{arg_num}mem", imm_val]
+        @indexed_vars[ref_name] = ["#{arg_num}reg", imm_val]
+      end
+
+      def create_equivalent(name, arg, delta)
+        arg = normalize(arg, delta)
+        if arg.first.include?("mem") || arg.first.include?("reg")
+          imm_val = arg.last
+          # remove mem/reg part
+          arg_num = arg[0][0..-4]
           name = name[1..-1]
-          arg = arg[0..-4]
 
-          @sugar["$#{name}"] = "#{arg}mem"
-          @sugar["&#{name}"] = "#{arg}reg"
+          mem_name = "$#{name}"
+          ref_name = "&#{name}"
+          @indexed_vars.delete(mem_name)
+          @indexed_vars.delete(ref_name)
+
+          imm_str = " #{imm_val}.imm" if imm_val > 0
+          @equivalents[mem_name] = "#{arg_num}mem#{imm_str}"
+          @equivalents[ref_name] = "#{arg_num}reg#{imm_str}"
         else
-          @sugar[name] = arg
+          @indexed_vars.delete(name)
+          @equivalents[name] = arg.first
         end
       end
 
+      def update_variable(arg, delta)
+        arg = arg.sub('reg', 'mem')
+        ['mem', 'reg'].each do |type|
+          variable = arg.sub('mem', type)
+          @indexed_vars.each do |name, value|
+            value[1] += delta if value.first == variable
+          end
+        end
+      end
+
+      def get_var(name)
+        val = @equivalents[name]
+        val ||=
+          begin
+            pair = @indexed_vars[name]
+            "#{pair.first} #{pair.last}.imm" if pair
+          end
+        val || name
+      end
+
       def parse
+        instruction = nil
+        names = []
+        op = nil
         if FUNCTION_REGEX =~ @minimal
-          parse_function_call
+          return parse_function_call
         elsif SUGAR_REGEX =~ @minimal
           match = SUGAR_REGEX.match(@minimal)
-          name = match['name']
-          if match['op'] == 'as'
-            create_variable(name, match['param'])
-            []
-          elsif match['op'] == '='
-            @minimal = match['param']
-            instruction = Instruction.new(@label_generator, minimal, original, @sugar)
-            dest = instruction.dest
-            if [1, 2, 3].include?(dest)
-              create_variable(name, "#{dest}.mem")
-            else
-              dest -= 4 if dest > 4
-              create_variable(name, "#{dest}.reg")
-            end
-            [instruction]
+          op = match['op']
+          names = match['names'].split(',').map(&:strip)
+
+          @minimal = match['param']
+          if minimal.start_with?('copy') || minimal.start_with?('compute')
+            instruction = Instruction.new(@label_generator, @minimal, original, self)
           else
-            raise ArgumentError, "Invalid syntax declaration: #{@minimal}"
+            var = match['param']
+            imm_match = IMM_REGEX.match(var)
+            imm_val = imm_match ? imm_match['imm_val'].to_i : 0
+            var = var.to_s.gsub(IMM_REGEX, '').strip
+            @minimal = "#{get_var(var)}#{" #{imm_val}.imm" if imm_val != 0}"
           end
         else
-          [Instruction.new(@label_generator, @minimal, original, @sugar)]
+          instruction = Instruction.new(@label_generator, @minimal, original, self)
         end
+        if instruction && instruction.instruction?
+          dest = instruction.dest
+          if instruction.inc && instruction.inc > 0
+            if dest > 4
+              # pop
+              update_variable("#{dest - 4}.mem", -1)
+            else
+              # push
+              update_variable("#{dest}.mem", 1)
+            end
+          end
+          if minimal.start_with?('copy') && dest > 4 && instruction.src == dest
+            # Manually modifying a register
+            update_variable("#{dest - 4}.mem", -1 * instruction.immediates.first)
+          end
+          dest -= 4 if dest > 4
+          @minimal = "#{dest}.mem"
+        end
+        names.each_with_index do |name, index|
+          if op == 'as'
+            create_equivalent(name, @minimal, index)
+          elsif op == '='
+            create_variable(name, @minimal, index)
+          end
+        end
+        [instruction].compact
       end
 
       def parse_function_call
@@ -69,7 +150,7 @@ module MicroCisc
         label = match['label']
 
         stack = match['stack']
-        stack = @sugar[stack] if @sugar[stack]
+        stack = get_var(stack)
         raise ArgumentError, "Invalid stack param, mem register expected: #{stack}" unless stack =~ /^[1-3]\.mem$/
         stackp = stack.sub('mem', 'reg')
 
@@ -79,15 +160,15 @@ module MicroCisc
         instructions = []
         if return_words > 0
           instruction = "copy #{stackp} -#{return_words}.imm #{stackp}"
-          instructions << Instruction.new(@label_generator, instruction, "  #{instruction} # return vars - #{original}", @sugar)
+          instructions << Instruction.new(@label_generator, instruction, "  #{instruction} # return vars - #{original}", self)
         end
 
         instruction = "copy 0.reg #{args.size + 2}.imm #{stack} push"
-        instructions << Instruction.new(@label_generator, instruction, "  #{instruction} # return addr - #{original}", @sugar)
+        instructions << Instruction.new(@label_generator, instruction, "  #{instruction} # return addr - #{original}", self)
 
         stack_delta = 1 + return_words
         args = args.each do |arg|
-          arg = arg.split(' ').map { |a| @sugar[a] || a }.join(' ')
+          arg = arg.split(' ').map { |a| get_var(a) || a }.join(' ')
           is_stack = arg.start_with?(stack)
           if is_stack
             offset = stack_delta
@@ -102,10 +183,13 @@ module MicroCisc
           end
           instruction = "copy #{arg} #{stack} push"
           stack_delta += 1
-          instructions << Instruction.new(@label_generator, instruction, "  #{instruction} # push arg - #{original}", @sugar)
+          instructions << Instruction.new(@label_generator, instruction, "  #{instruction} # push arg - #{original}", self)
         end
         instruction = "copy 0.reg #{label}.disp 0.reg"
-        instructions << Instruction.new(@label_generator, instruction, "  #{instruction} # call - #{original}", @sugar)
+        instructions << Instruction.new(@label_generator, instruction, "  #{instruction} # call - #{original}", self)
+        if return_words > 0
+          update_variable(stack, return_words)
+        end
         instructions
       end
     end