idlc 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7afb7419f8d68fe843767795803581f71b8b82f4f160f12620240e26fd959eae
-  data.tar.gz: 75017626ea863fc6d80db787eb829450ec1b0663520607b547bfa7c5c2be81c7
+  metadata.gz: 2fe70767fa4481a7e6085a724b275eb06c92629fdf4408ad2e0f0f815bfb65b1
+  data.tar.gz: 9d41295be8e44be071bcfef86af5e5995b596a464ce6c6c91d5510d7818940f4
 SHA512:
-  metadata.gz: 718129ce9fca746406948debcf0563ae705f5e0f5e5e8e62bc129d75d2cb9352aa999cb1bb16f3d252d95398c7d2f4debe4af67e9b7d755f9ba9a21848fb977e
-  data.tar.gz: a6595cf7d2e9ba63a02ae37fe690c8b06f12c7c45bb5badc221ff9e7ad3446caa1cffd0bc8354c4083b5e0ef95511fb11ad8cd71c146d36a63a76740094ea32e
+  metadata.gz: 1e291366c4dbfadcbfa2c7a4d3caff30fc3c71c93b1162ede1b2a2e8f1a652a4c17764eaf634434266ba092caef12c7012ffa1b139f85dd48fb10871da574025
+  data.tar.gz: a63b1fdc428d772f72d1377d36142afcebbcdd01bed484ffac8229d36072b78130fe14a907f657eff6145941adb3f6a7c21da773e0c899c20165a8d92eb85e75

data/lib/idlc/ast.rb

@@ -2967,7 +2967,10 @@ module Idl
 
       value_result = value_try do
         idx_value = idx.value(symtab)
-        type_error "Array index (#{idx.text_value} = #{idx_value}) out of range (< #{lhs.type(symtab).width})" if idx_value >= lhs.type(symtab).width
+        lhs_width = lhs.type(symtab).width
+        if lhs_width != :unknown && idx_value >= lhs_width
+          type_error "Array index (#{idx.text_value} = #{idx_value}) out of range (< #{lhs_width})"
+        end
       end
       # OK, doesn't need to be known
 
@@ -4799,27 +4802,12 @@ module Idl
     # @return [Integer] the number of bits needed to represent value in two's complement
     def bits_needed(value, signed)
       if signed
-        case value
-        when 0
-          1
-        when 1
-          2
-        else
-          if value > 0
-            # need bit_legnth plus a sign bit
-            bits = value.bit_length + 1
-          else
-            # need bit_length plus a sign bit, unless value is a power of 2
-            if (value.abs & (value.abs - 1)) == 0
-              value.bit_length
-            else
-              value.bit_length + 1
-            end
-          end
-        end
+        # add sign bit
+        value.bit_length + 1
       else
         internal_error "unsigned value is negative" if value < 0
 
+        # 0 needs a single bit; `0.bit_length` returns 0.
         value == 0 ? 1 : value.bit_length
       end
     end
@@ -9388,7 +9376,9 @@ module Idl
 
     sig { params(symtab: SymbolTable).returns(CsrField) }
     def field_def(symtab)
-      T.must(csr_obj(symtab).fields.find { |f| f.name == @field_name })
+      field = csr_obj(symtab).fields.find { |f| f.name == @field_name }
+      type_error "#{@field_name} is not a field of CSR[#{csr_name}]" if not field
+      field
     end
 
     sig { params(symtab: SymbolTable).returns(String) }

data/lib/idlc/passes/prune.rb

@@ -20,8 +20,18 @@ module Idl
       width = forced_type ? forced_type.width : value.bit_length
       raise "pruning error: attempting to prune an integer with unknown width" unless width.is_a?(Integer)
       width = 1 if width == 0
-      v = value <= 512 ? value.to_s : "h#{value.to_s(16)}"
-      str = "#{width}'#{v}"
+
+      # negative values must keep an explicit sign marker and their native decimal
+      # text; the literal grammar already parses signed negative decimals correctly,
+      # while re-encoding as an unsigned magnitude (with no sign marker) silently
+      # drops the sign once rendered to C++ (see IntLiteralAst#gen_cpp)
+      str =
+        if value.is_a?(Integer) && value.negative?
+          "#{width}'sd#{value}"
+        else
+          v = value <= 512 ? value.to_s : "h#{value.to_s(16)}"
+          "#{width}'#{v}"
+        end
       Idl::IntLiteralAst.new(str, 0...str.size, str)
     end
 
@@ -694,7 +704,10 @@ module Idl
     def prune(symtab, forced_type: nil)
       if forced_type
         raise "pruning error: attempt to force bitwidth when width is unknown" if forced_type.width.nil? || forced_type.width == :unknown
-        s = "#{forced_type.width}'d#{value(symtab)}"
+        v = value(symtab)
+        # negative values need an explicit sign marker; without it, the literal
+        # re-parses as unsigned and loses its sign once rendered to C++
+        s = v.negative? ? "#{forced_type.width}'sd#{v}" : "#{forced_type.width}'d#{v}"
         IntLiteralAst.new(s, 0...s.size, s)
       else
         dup

data/lib/idlc/type.rb

@@ -464,6 +464,14 @@ module Idl
       self
     end
 
+    sig { params(value: Integer).returns(Integer) }
+    def self.unsigned_bits_needed(value)
+      raise "unsigned JSON schema integer cannot be negative" if value.negative?
+
+      value.zero? ? 1 : value.bit_length
+    end
+    private_class_method :unsigned_bits_needed
+
     # @return [Idl::Type] Type of a scalar
     # @param schema [Hash] JSON Schema description of a scalar
     sig { params(schema: T::Hash[String, T.untyped]).returns(T.nilable(Type)) }
@@ -474,9 +482,9 @@ module Idl
           Type.new(:boolean)
         when "integer"
           if schema.key?("enum")
-            Type.new(:bits, width: schema["enum"].max.bit_length)
+            Type.new(:bits, width: schema["enum"].map { |e| unsigned_bits_needed(e) }.max)
           elsif schema.key?("maximum")
-            Type.new(:bits, width: schema["maximum"].bit_length)
+            Type.new(:bits, width: unsigned_bits_needed(schema["maximum"]))
           else
             Type.new(:bits, width: 128)
           end
@@ -494,7 +502,7 @@ module Idl
         when TrueClass, FalseClass
           Type.new(:boolean)
         when Integer
-          Type.new(:bits, width: schema["const"].bit_length)
+          Type.new(:bits, width: unsigned_bits_needed(schema["const"]))
         when String
           Type.new(:string, width: schema["const"].length)
         else
@@ -507,7 +515,7 @@ module Idl
         when TrueClass, FalseClass
           Type.new(:boolean)
         when Integer
-          Type.new(:bits, width: schema["enum"].map { |e| e.bit_length }.max)
+          Type.new(:bits, width: schema["enum"].map { |e| unsigned_bits_needed(e) }.max)
         when String
           Type.new(:string, width: schema["enum"].map { |e| e.length }.max)
         else
@@ -551,6 +559,27 @@ module Idl
     end
     private_class_method :from_json_schema_scalar_type
 
+    sig { params(types: T::Array[Type]).returns(Type) }
+    def self.merge_json_schema_scalar_types(types)
+      raise "No scalar types" if types.empty?
+
+      first = types.fetch(0)
+      kind = first.kind
+      raise "Schema error: Array elements must be the same type" unless types.all? { |t| t.kind == kind }
+
+      if kind == :bits
+        unknown_width_type = types.find { |t| t.width == :unknown }
+        return unknown_width_type unless unknown_width_type.nil?
+
+        Type.new(:bits, width: T.must(types.map(&:width).max))
+      else
+        raise "Schema error: Array elements must be the same type" unless types.all? { |t| first.equal_to?(t) }
+
+        first
+      end
+    end
+    private_class_method :merge_json_schema_scalar_types
+
     # @return [Idl::Type] Type of array
     # @param schema [Hash] JSON Schema description of an array
     sig { params(schema: T::Hash[String, T.untyped]).returns(Type) }
@@ -566,25 +595,9 @@ module Idl
         raise "unexpected #{schema}" unless schema["items"].is_a?(Array)
 
         # this ia an array with each element specified
-        sub_type = T.let(nil, T.nilable(Type))
-        schema["items"].each do |item_schema|
-          if sub_type.nil?
-            sub_type = from_json_schema_scalar_type(item_schema)
-          else
-            unless sub_type.equal_to?(from_json_schema_scalar_type(item_schema))
-              raise "Schema error: Array elements must be the same type (#{sub_type} #{from_json_schema_scalar_type(item_schema)}) \n#{schema["items"]}"
-            end
-          end
-        end
-        if schema.key?("additionalItems")
-          if sub_type.nil?
-            sub_type = from_json_schema_scalar_type(schema["additionalItems"])
-          else
-            unless sub_type.equal_to?(from_json_schema_scalar_type(schema["additionalItems"]))
-              raise "Schema error: Array elements must be the same type"
-            end
-          end
-        end
+        item_types = schema["items"].map { |item_schema| from_json_schema_scalar_type(item_schema) }
+        item_types << from_json_schema_scalar_type(schema["additionalItems"]) if schema.key?("additionalItems")
+        sub_type = merge_json_schema_scalar_types(item_types.compact)
         Type.new(:array, width:, sub_type:)
       end
     end

data/lib/idlc/version.rb

@@ -5,6 +5,6 @@
 
 module Idl
   class Compiler
-    def self.version = "0.1.6"
+    def self.version = "0.1.8"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: idlc
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Derek Hower
 bindir: bin
 cert_chain: []
-date: 2026-08-02 00:00:00.000000000 Z
+date: 2026-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -369,7 +369,7 @@ licenses:
 - BSD-3-Clause-Clear
 metadata:
   homepage_uri: https://github.com/riscv/riscv-unified-db
-  mailing_list_uri: https://lists.riscv.org/g/tech-unifieddb
+  mailing_list_uri: https://lists.riscv.org/g/sig-unifieddb
   bug_tracker_uri: https://github.com/riscv/riscv-unified-db/issues
 rdoc_options: []
 require_paths: