systemrdl 0.1.0

data/lib/systemrdl/parser/node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Parser
+    class Node < AST::Node
+      attr_reader :token_range
+
+      def replace_type(type)
+        updated(type, nil, nil)
+      end
+
+      def replace_token_range(token_range)
+        updated(nil, nil, { token_range: token_range })
+      end
+    end
+  end
+end

data/lib/systemrdl/parser/parser.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Parser
+    class Parser < GeneratedParser
+      include RaiseParseError
+
+      def initialize(scanner, debug: false)
+        @scanner = scanner
+        @yydebug = debug
+        super()
+      end
+
+      def parse
+        do_parse
+      end
+
+      private
+
+      def next_token
+        @scanner.next_token
+      end
+
+      def on_error(_token_id, value, _value_stack)
+        parse_error(value)
+      end
+
+      def parse_error(value)
+        message = "syntax error on value '#{value.text}' (#{value.kind})"
+        raise_parse_error message, value.position
+      end
+
+      def to_list(values, include_separator:)
+        if include_separator
+          [values[0], *values[1]&.map { |_, value| value }]
+        else
+          [values[0], *values[1]]
+        end
+      end
+
+      def node(kind, children, values)
+        token_range = to_token_range(values)
+        Node.new(kind, children, { token_range: token_range })
+      end
+
+      def array_node(values)
+        values = values.flatten
+        children = values.filter_map.with_index { |v, i| i % 3 == 1 ? v : nil }
+        node(:array, children, values)
+      end
+
+      def component_insts_node(type, insts)
+        case type&.kind
+        when :EXTERNAL then insts.replace_type(:external_component_insts)
+        when :INTERNAL then insts.replace_type(:internal_component_insts)
+        end
+      end
+
+      def component_inst_node(values)
+        array, range = values[1]
+        node(:component_inst, [values[0], array, range, *values[2..]], values)
+      end
+
+      def uop_node(values)
+        node(:unary_operation, values, values)
+      end
+
+      def bop_node(values)
+        node(:binary_operation, [values[1], values[0], values[2]], values)
+      end
+
+      def to_token_range(values)
+        values = values.compact
+        head = values.first
+        tail = values.last
+        if values.size == 1 && head.is_a?(Node)
+          head.token_range
+        else
+          head_token = (head.is_a?(Node) && head.token_range.head) || head
+          tail_token = (tail.is_a?(Node) && tail.token_range.tail) || tail
+          TokenRange.new(head_token, tail_token)
+        end
+      end
+    end
+  end
+end

data/lib/systemrdl/parser/scanner.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module SystemRDL
+  module Parser
+    class Scanner
+      include RaiseParseError
+
+      class << self
+        private
+
+        def keyword_patterns
+          [
+            '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'
+          ].to_h { |kw| [kw, kw.upcase.to_sym] }.freeze
+        end
+
+        def symbol_patterns
+          patterns = [
+            '[', ']', '(', ')', '{', '}',
+            '!', '&&', '||', '<', '>', '<=', '>=', '==', '!=', '>>', '<<',
+            '~', '&', '~&', '|', '~|', '^', '~^', '^~', '*', '/', '%', '+', '-', '**',
+            '?', ':', '->', '.', ',', "'", ';', '=', '@', '+=', '%='
+          ]
+          patterns
+            .sort_by(&:size)
+            .reverse
+            .to_h { |pattern| [Regexp.new(Regexp.escape(pattern)), pattern] }
+            .freeze
+        end
+      end
+
+      WHITE_SPACES = /[ \t\n\r]+/
+
+      LINE_COMMENT = %r{//.*$}
+      BLOCK_COMMENT = %r{/\*(?:(?!\*/).)*\*/}m
+      UNTERMINATED_BLOCK_COMMENT = %r{/\*(?:(?!\*/).)*}m
+
+      KEYWORDS = keyword_patterns
+
+      SYMBOLS = symbol_patterns
+
+      VERILOG_BIN_NUMBER = /(\d+)'[bB]([01][01_]*)/
+      VERILOG_DEC_NUMBER = /(\d+)'[dD](\d[\d_]*)/
+      VERILOG_HEX_NUMBER = /(\d+)'[hH](\h[\h_]*)/
+
+      DEC_NUMBER = /\d[\d_]*/
+      HEX_NUMBER = /0[xX]\h[\h_]*/
+
+      NUMBERS = {
+        VERILOG_HEX_NUMBER => :VERILOG_NUMBER,
+        VERILOG_DEC_NUMBER => :VERILOG_NUMBER,
+        VERILOG_BIN_NUMBER => :VERILOG_NUMBER,
+        HEX_NUMBER => :NUMBER,
+        DEC_NUMBER => :NUMBER
+      }.freeze
+
+      def initialize(code, filename, test)
+        @ss = StringScanner.new(code)
+        @filename = filename
+        @line = 1
+        @column = 1
+        @control_tokens = []
+        @control_tokens << create_test_token(test) if test
+      end
+
+      def next_token
+        if @control_tokens.empty?
+          skip_blank
+          push_eos_tokens if eos?
+        end
+
+        token =
+          if @control_tokens.empty?
+            scan_next_token
+          else
+            @control_tokens.shift
+          end
+        token && [token.kind, token]
+      end
+
+      private
+
+      def eos?
+        @ss.eos?
+      end
+
+      def skip_blank
+        loop do
+          next if scan(WHITE_SPACES)
+          next if scan(LINE_COMMENT)
+          next if scan_block_comment
+
+          break
+        end
+      end
+
+      def scan_block_comment
+        comment = scan(BLOCK_COMMENT)
+        return comment if comment
+
+        if (_, line, column = scan(UNTERMINATED_BLOCK_COMMENT))
+          pos = Position.new(@filename, line, column)
+          raise_parse_error 'unterminated block comment', pos
+        end
+      end
+
+      def push_eos_tokens
+        @control_tokens << create_control_token(:EOS)
+        @control_tokens << nil
+      end
+
+      def scan(pattern)
+        text = @ss.scan(pattern)
+        return unless text
+
+        line = @line
+        column = @column
+        update_state(text)
+
+        [text, line, column]
+      end
+
+      def scan_token(kind, pattern)
+        text, line, column = scan(pattern)
+        text && create_token(kind, text, line, column)
+      end
+
+      def peek(pattern)
+        @ss.check(pattern)
+      end
+
+      def peek_char
+        peek(/./m)
+      end
+
+      def advance(text)
+        @ss.pos += text.bytesize
+        update_state(text)
+      end
+
+      def update_state(text)
+        return if text.empty?
+
+        n_newline = text.count("\n")
+        @line += n_newline
+
+        @column =
+          if text[-1] == "\n"
+            1
+          elsif n_newline > 0
+            last = text.lines.last
+            last.length
+          else
+            @column + text.length
+          end
+      end
+
+      def create_token(kind, text, line, column)
+        position = Position.new(@filename, line, column)
+        Token.new(text, kind, position)
+      end
+
+      def create_control_token(kind)
+        create_token(kind, '', @line, @column)
+      end
+
+      def create_test_token(test)
+        kind = :"__test_#{test}__".upcase
+        create_control_token(kind)
+      end
+
+      def current_position
+        Position.new(@filename, @line, @column)
+      end
+
+      def scan_next_token
+        token =
+          scan_string || scan_number || scan_symbol || scan_word
+        return token if token
+
+        char = peek_char
+        raise_parse_error "illegal character `#{char}`", current_position
+      end
+
+      def scan_string
+        return unless peek(/"/)
+
+        line = @line
+        column = @column
+
+        buffer = []
+        while (char = peek_char)
+          advance(char)
+          if char == '\\' && ((next_char, _, _) = scan(/"/))
+            buffer << next_char
+          else
+            buffer << char
+            break if buffer.size >= 2 && buffer.last == '"'
+          end
+        end
+
+        text = buffer.join
+        create_token(:STRING, text, line, column)
+      end
+
+      def scan_number
+        NUMBERS.each do |pattern, kind|
+          token = scan_token(kind, pattern)
+          return token if token
+        end
+
+        nil
+      end
+
+      def scan_symbol
+        SYMBOLS.each do |pattern, kind|
+          token = scan_token(kind, pattern)
+          return token if token
+        end
+
+        nil
+      end
+
+      def scan_word
+        text, line, column = scan(/[_a-zA-Z]\w*/)
+        return unless text
+
+        KEYWORDS.each do |pattern, kind|
+          next if text != pattern
+
+          token = create_token(kind, text, line, column)
+          return token
+        end
+
+        create_token(:SIMPLE_ID, text, line, column)
+      end
+    end
+  end
+end