systemrdl 0.1.0

data/lib/systemrdl/parser/systemrdl.y

@@ -0,0 +1,448 @@
+class SystemRDL::Parser::GeneratedParser
+token
+  # Keywords
+  ABSTRACT ACCESSTYPE ADDRESSINGTYPE ADDRMAP ALIAS
+  ALL BIT BOOLEAN BOTHEDGE COMPACT
+  COMPONENT COMPONENTWIDTH CONSTRAINT DEFAULT ENCODE
+  ENUM EXTERNAL FALSE FIELD FULLALIGN
+  HW INSIDE INTERNAL LEVEL LONGINT
+  MEM NA NEGEDGE NONSTICKY NUMBER
+  ONREADTYPE ONWRITETYPE POSEDGE PROPERTY R
+  RCLR REF REG REGALIGN REGFILE
+  RSET RUSER RW RW1 SIGNAL
+  STRING STRUCT SW THIS TRUE
+  TYPE UNSIGNED W W1 WCLR
+  WOCLR WOSET WOT WR WSET
+  WUSER WZC WZS WZT
+  # Literal
+  STRING
+  NUMBER
+  VERILOG_NUMBER
+  # Identifier
+  SIMPLE_ID
+  # Conrol tokens
+  EOS
+  __TEST_PROPERTY_ASSIGNMENT__
+  __TEST_CONSTANT_EXPRESSION__
+
+prechigh
+  nonassoc UOP
+  left     "**"
+  left     "*" "/" "%"
+  left     "+" "-"
+  left     "<<" ">>"
+  left     "<" "<=" ">" ">="
+  left     "==" "!="
+  left     "&"
+  left     "^" "~^" "^~"
+  left     "|"
+  left     "&&"
+  left     "||"
+  right    "?" ":"
+preclow
+
+rule
+  #
+  # B.1 SystemRDL source text
+  #
+  root
+    : description+ EOS {
+      result = node(:root, val[0], val[0])
+    }
+    | __TEST_PROPERTY_ASSIGNMENT__ property_assignment EOS {
+        result = val[1]
+      }
+    | __TEST_CONSTANT_EXPRESSION__ constant_expression EOS {
+        result = val[1]
+      }
+  description
+    : component_def
+
+  #
+  # B.3 Component definition
+  #
+  component_def
+    : component_type id "{" component_body_elem* "}" component_inst_type component_insts ";" {
+        insts = component_insts_node(val[5], val[6])
+        result = node(:component_named_def, [val[0], val[1], *val[3], insts], val)
+      }
+    | component_type "{" component_body_elem* "}" component_inst_type component_insts ";" {
+        insts = component_insts_node(val[4], val[5])
+        result = node(:component_anon_def, [val[0], *val[2], insts], val)
+      }
+    | component_type id "{" component_body_elem* "}" component_insts ";" {
+        result = node(:component_named_def, [val[0], val[1], *val[3], val[5]], val)
+      }
+    | component_type id "{" component_body_elem* "}" ";" {
+        result = node(:component_named_def, [val[0], val[1], *val[3]], val)
+      }
+    | component_type "{" component_body_elem* "}" component_insts ";" {
+        result = node(:component_anon_def, [val[0], *val[2], val[4]], val)
+      }
+    | component_inst_type component_type id "{" component_body_elem* "}" component_insts ";" {
+        insts = component_insts_node(val[0], val[6])
+        result = node(:component_named_def, [val[1], val[2], *val[4], insts], val)
+      }
+    | component_inst_type component_type "{" component_body_elem* "}" component_insts ";" {
+        insts = component_insts_node(val[0], val[5])
+        result = node(:component_anon_def, [val[1], *val[3], insts], val)
+      }
+  component_body_elem
+    : component_def
+    | property_assignment
+    | explicit_component_inst
+  component_type
+    : ADDRMAP | REGFILE | REG | FIELD | MEM
+  explicit_component_inst
+    : id component_insts ";" {
+        result = node(:explicit_component_inst, val[..1], val)
+      }
+    | component_inst_type id component_insts ";" {
+        insts = component_insts_node(val[0], val[2])
+        result = node(:explicit_component_inst, [val[1], insts], val)
+    }
+  component_insts
+    : component_inst ("," component_inst)* {
+        result = node(:component_insts, to_list(val, include_separator: true), val)
+      }
+  component_inst
+    : id component_inst_array_or_range? reset_value? address_assignment? address_stride? address_alignment? {
+        result = component_inst_node(val)
+      }
+  reset_value
+    : "=" constant_expression {
+        result = node(:reset_value, [val[1]], val)
+      }
+  address_assignment
+    : "@" constant_expression {
+        result = node(:address_assignment, [val[1]], val)
+      }
+  address_stride
+    : "+=" constant_expression {
+        result = node(:address_stride, [val[1]], val)
+      }
+  address_alignment
+    : "%=" constant_expression {
+        result = node(:address_alignment, [val[1]], val)
+      }
+  component_inst_type
+    : EXTERNAL
+    | INTERNAL
+  component_inst_array_or_range
+    : array {
+        result = [val[0], nil]
+      }
+    | range {
+        result = [nil, val[0]]
+      }
+
+  #
+  # B.8 Property assignment
+  #
+  property_assignment
+    : DEFAULT prop_mod id ";" {
+        result = node(:default_prop_modifier, val[1..2], val)
+      }
+    | prop_mod id ";" {
+        result = node(:prop_modifier, val[0..1], val)
+      }
+    | DEFAULT prop_assignment_lhs ";" {
+        result = node(:default_prop_assignment, [val[1]], val)
+      }
+    | prop_assignment_lhs ";" {
+        result = node(:prop_assignment, [val[0]], val)
+      }
+    | DEFAULT prop_assignment_lhs "=" prop_assignment_rhs ";" {
+        result = node(:default_prop_assignment, [val[1], val[3]], val)
+      }
+    | prop_assignment_lhs "=" prop_assignment_rhs ";" {
+        result = node(:prop_assignment, [val[0], val[2]], val)
+      }
+    | DEFAULT encode "=" id ";" {
+        result = node(:default_prop_assignment, [val[1], val[3]], val)
+      }
+    | encode "=" id ";" {
+        result = node(:prop_assignment, [val[0], val[2]], val)
+      }
+    | prop_ref ";" {
+        result = node(:post_prop_assignment, [val[0]], val)
+      }
+    | prop_ref "=" prop_assignment_rhs ";" {
+        result = node(:post_prop_assignment, [val[0], val[2]], val)
+      }
+    | encode_ref "=" id ";" {
+        result = node(:post_prop_assignment, [val[0], val[2]], val)
+      }
+  prop_mod
+    : POSEDGE | NEGEDGE | BOTHEDGE | LEVEL | NONSTICKY
+  prop_assignment_lhs
+    : id
+    | prop_keyword
+  prop_keyword
+    : SW {
+        result = node(:id, val, val)
+      }
+    | HW {
+        result = node(:id, val, val)
+      }
+    | RCLR {
+        result = node(:id, val, val)
+      }
+    | RSET {
+        result = node(:id, val, val)
+      }
+    | WOCLR {
+        result = node(:id, val, val)
+      }
+    | WOSET {
+        result = node(:id, val, val)
+      }
+  prop_assignment_rhs
+    : constant_expression
+    | precedencetype_literal {
+        result = node(:precedencetype, val, val)
+      }
+  encode
+    : ENCODE {
+        result = node(:id, val, val)
+      }
+  encode_ref
+    : instance_ref "->" encode {
+        result = node(:prop_ref, [val[0], val[2]], val)
+      }
+
+  #
+  # B.11 Reference
+  #
+  instance_ref
+    : instance_ref_element ("." instance_ref_element)* {
+        result = node(:instance_ref, to_list(val, include_separator: true), val)
+      }
+  prop_ref
+    : instance_ref "->" id {
+        result = node(:prop_ref, [val[0], val[2]], val)
+      }
+    | instance_ref "->" prop_keyword {
+        result = node(:prop_ref, [val[0], val[2]], val)
+      }
+  instance_or_prop_ref
+    : prop_ref
+    | instance_ref
+  instance_ref_element
+    : id array {
+      result = node(:instance_ref_element, val, val)
+    }
+    | id {
+      result = node(:instance_ref_element, val, val)
+    }
+
+  #
+  # B.12 Array and range
+  #
+  range
+    : "[" constant_expression ":" constant_expression "]" {
+        result = node(:range, [val[1], val[3]], val)
+      }
+  array
+    : ("[" constant_expression "]")+ {
+        result = array_node(val)
+      }
+
+  #
+  # B.13 Concatenation
+  #
+  constant_concatenation
+    : "{" constant_expression ("," constant_expression)* "}" {
+        result = node(:concatenation, to_list(val[1..-2], include_separator: true), val)
+      }
+  constant_multiple_concatenation
+    : "{" constant_expression constant_concatenation "}" {
+      result = node(:replication, val[1..2], val)
+    }
+
+  #
+  # B.14 Data types
+  #
+  simple_type
+    : LONGINT {
+        result = node(:data_type, val, val)
+      }
+    | BIT {
+        result = node(:data_type, val, val)
+      }
+
+  #
+  # B.15 Literals
+  #
+  boolean_literal
+    : TRUE | FALSE
+  accesstype_literal
+    : NA | RW | WR | R | W | RW1 | W1
+  onreadtype_literal
+    : RCLR | RSET | RUSER
+  onwritetype_literal
+    : WOSET | WOCLR | WOT | WZS | WZC | WZT | WCLR | WSET | WUSER
+  addressingtype_literal
+    : COMPACT | REGALIGN | FULLALIGN
+  precedencetype_literal
+    : HW | SW
+
+  #
+  # B.16 Expressions
+  #
+  constant_expression
+    : constant_primary
+    | "!" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "+" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "-" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "~" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "&" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "~&" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "|" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "~|" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "^" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "~^" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | "^~" constant_expression = UOP {
+        result = uop_node(val)
+      }
+    | constant_expression "&&" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "||" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "<" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression ">" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "<=" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression ">=" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "==" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "!=" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression ">>" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "<<" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "&" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "|" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "^" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "~^" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "^~" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "*" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "/" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "%" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "+" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "-" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "**" constant_expression {
+        result = bop_node(val)
+      }
+    | constant_expression "?" constant_expression ":" constant_expression {
+        result = node(:conditional_operation, [val[0], val[2], val[4]], val)
+      }
+  constant_primary
+    : primary_literal
+    | constant_concatenation
+    | constant_multiple_concatenation
+    | "(" constant_expression ")" {
+        result = val[1].replace_token_range(to_token_range(val))
+      }
+    | constant_cast
+    | instance_or_prop_ref
+  primary_literal
+    : boolean_literal {
+        result = node(:boolean, val, val)
+      }
+    | STRING {
+        result = node(:string, val, val)
+      }
+    | NUMBER {
+        result = node(:number, val, val)
+      }
+    | VERILOG_NUMBER {
+        result = node(:verilog_number, val, val)
+      }
+    | accesstype_literal {
+        result = node(:accesstype, val, val)
+      }
+    | onreadtype_literal {
+        result = node(:onreadtype, val, val)
+      }
+    | onwritetype_literal {
+        result = node(:onwritetype, val, val)
+      }
+    | addressingtype_literal {
+        result = node(:addressingtype, val, val)
+      }
+    | THIS {
+        result = node(:this, val, val)
+    }
+    constant_cast
+      : casting_type "'" "(" constant_expression ")" {
+          result = node(:cast, [val[0], val[3]], val)
+        }
+    casting_type
+      : simple_type
+      | constant_primary
+      | BOOLEAN {
+          result = node(:data_type, val, val)
+        }
+
+  #
+  # B.17 Identifiers
+  #
+  id
+    : SIMPLE_ID {
+        result = node(:id, val, val)
+      }

data/lib/systemrdl/parser/token.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Parser
+    class Position
+      def initialize(filename, line, column)
+        @filename = filename
+        @line = line
+        @column = column
+        freeze
+      end
+
+      attr_reader :filename
+      attr_reader :line
+      attr_reader :column
+
+      def to_s
+        "filename: #{filename} line: #{line} column: #{column}"
+      end
+    end
+
+    class Token
+      def initialize(text, kind, position)
+        @text = text
+        @kind = kind
+        @position = position
+        freeze
+      end
+
+      attr_reader :text
+      attr_reader :kind
+      attr_reader :position
+
+      def to_sym
+        text.to_sym
+      end
+
+      def to_token_range
+        TokenRange.new(self)
+      end
+
+      def ==(other)
+        text == ((other.is_a?(Token) && other.text) || other)
+      end
+    end
+
+    class TokenRange
+      def initialize(head, tail = nil)
+        @head = head
+        @tail = tail || head
+        freeze
+      end
+
+      attr_reader :head
+      attr_reader :tail
+    end
+  end
+end

data/lib/systemrdl/parser.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Parser
+    def self.parse(code, filename: 'unknown', debug: false, test: nil)
+      scanner = Scanner.new(code, filename, test)
+      parser = Parser.new(scanner, debug:)
+      parser.parse
+    end
+  end
+end

data/lib/systemrdl/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  VERSION = '0.1.0'
+end

data/lib/systemrdl.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'strscan'
+require 'ast'
+
+require_relative 'systemrdl/version'
+require_relative 'systemrdl/error'
+require_relative 'systemrdl/parser/token'
+require_relative 'systemrdl/parser/scanner'
+require_relative 'systemrdl/parser/node'
+require_relative 'systemrdl/parser/generated_parser'
+require_relative 'systemrdl/parser/parser'
+require_relative 'systemrdl/parser'
+require_relative 'systemrdl/evaluator/value'
+require_relative 'systemrdl/evaluator/common'
+require_relative 'systemrdl/evaluator/list'
+require_relative 'systemrdl/evaluator/literal'
+require_relative 'systemrdl/evaluator/operation'
+require_relative 'systemrdl/evaluator/instance'
+require_relative 'systemrdl/evaluator/reference'
+require_relative 'systemrdl/evaluator/property'
+require_relative 'systemrdl/evaluator/property_assignment'
+require_relative 'systemrdl/evaluator/builtin_properties'
+require_relative 'systemrdl/evaluator/component_insts'
+require_relative 'systemrdl/evaluator/component_definition'
+require_relative 'systemrdl/evaluator/address_operation'
+require_relative 'systemrdl/evaluator/address_allocation'
+require_relative 'systemrdl/evaluator/array_component'
+require_relative 'systemrdl/evaluator/container_component'
+require_relative 'systemrdl/evaluator/field'
+require_relative 'systemrdl/evaluator/reg'
+require_relative 'systemrdl/evaluator/regfile'
+require_relative 'systemrdl/evaluator/addrmap'
+require_relative 'systemrdl/evaluator/root'
+require_relative 'systemrdl/evaluator/processor'
+require_relative 'systemrdl/evaluator'
+require_relative 'systemrdl/model/value'
+require_relative 'systemrdl/model/instance'
+require_relative 'systemrdl/model'
+
+module SystemRDL
+  class << self
+    def compile(*filenames)
+      __compile_multiple(filenames, :file_reader)
+    end
+
+    def compile_streams(streams)
+      __compile_multiple(streams, :stream_reader)
+    end
+
+    def compile_source(rdl, filename: 'unknown')
+      _, models = __compile(rdl, filename, nil, nil)
+      models
+    end
+
+    private
+
+    def file_reader(filename, &)
+      File.open(filename) { |f| stream_reader(filename, f, &) }
+    end
+
+    def stream_reader(filename, stream)
+      rdl = stream.read
+      yield(rdl, filename)
+    end
+
+    def __compile_multiple(inputs, reader)
+      _, models = inputs.inject([nil, nil]) do |(root, results), input|
+        __send__(reader, *input) do |rdl, filename|
+          __compile(rdl, filename, root, results)
+        end
+      end
+
+      models
+    end
+
+    def __compile(rdl, filename, root, results)
+      ast = Parser.parse(rdl, filename:)
+      evaluated = Evaluator.evaluate(ast, root)
+      models = Model.build(evaluated)
+
+      if results
+        results.concat(models)
+        [evaluated, results]
+      else
+        [evaluated, models]
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: systemrdl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Taichi Ishitani
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: A SystemRDL 2.0 front-end for Ruby
+email:
+- taichi730@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/systemrdl.rb
+- lib/systemrdl/error.rb
+- lib/systemrdl/evaluator.rb
+- lib/systemrdl/evaluator/address_allocation.rb
+- lib/systemrdl/evaluator/address_operation.rb
+- lib/systemrdl/evaluator/addrmap.rb
+- lib/systemrdl/evaluator/array_component.rb
+- lib/systemrdl/evaluator/builtin_properties.rb
+- lib/systemrdl/evaluator/common.rb
+- lib/systemrdl/evaluator/component_definition.rb
+- lib/systemrdl/evaluator/component_insts.rb
+- lib/systemrdl/evaluator/container_component.rb
+- lib/systemrdl/evaluator/field.rb
+- lib/systemrdl/evaluator/instance.rb
+- lib/systemrdl/evaluator/list.rb
+- lib/systemrdl/evaluator/literal.rb
+- lib/systemrdl/evaluator/operation.rb
+- lib/systemrdl/evaluator/processor.rb
+- lib/systemrdl/evaluator/property.rb
+- lib/systemrdl/evaluator/property_assignment.rb
+- lib/systemrdl/evaluator/reference.rb
+- lib/systemrdl/evaluator/reg.rb
+- lib/systemrdl/evaluator/regfile.rb
+- lib/systemrdl/evaluator/root.rb
+- lib/systemrdl/evaluator/value.rb
+- lib/systemrdl/model.rb
+- lib/systemrdl/model/instance.rb
+- lib/systemrdl/model/value.rb
+- lib/systemrdl/parser.rb
+- lib/systemrdl/parser/generated_parser.rb
+- lib/systemrdl/parser/node.rb
+- lib/systemrdl/parser/parser.rb
+- lib/systemrdl/parser/scanner.rb
+- lib/systemrdl/parser/systemrdl.y
+- lib/systemrdl/parser/token.rb
+- lib/systemrdl/version.rb
+homepage: https://github.com/taichi-ishitani/systemrdl
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/taichi-ishitani/systemrdl/issues
+  homepage_uri: https://github.com/taichi-ishitani/systemrdl
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/taichi-ishitani/systemrdl
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: A SystemRDL 2.0 front-end for Ruby
+test_files: []