vhdl_tb 0.7.7 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c923a4fa6709c50c3884373bccd42bf10d10edf991433583a3e9049893e890a
-  data.tar.gz: 9472e003ed9122fc25119a14694773427b18f7f2815d9c6be109587fc4469284
+  metadata.gz: 313f1e44991a5318c80cedf07f0762100a2bfd71171c6de3dcdf75a4b6594bfb
+  data.tar.gz: 7c6c361dfef387ae6767c4b59113145f0e71ab8e35217fa46272b8d69322fc32
 SHA512:
-  metadata.gz: efd367b33ef40a420bea6b2fc7466158d4b06003990e37ae4ef8b9f59ec24020c5d71a4b18e27a6aa370ca886a80ce4e635c7aa573e6a547dc244b4664a2d11a
-  data.tar.gz: 4a0d1c8094896ab286974dc0b7cc88d0d20b517fcaa5cbda9a3dfc2c0da5a786b089b079903c67a26967f0ee60283dfebee6da6b2cb408c1689db2680abebed1
+  metadata.gz: 2b8fdf9e01c639116a968b6e88873eeece3100ad9e7741b092ff6e98e2387a3391c9320ba0e7c7d484d2d9db3183026bcf8de09b7648d1d2379a043236b21e34
+  data.tar.gz: c4a5947e34d387336f174e8259991a9884080d35bebd6c8c50e38c5b8834f97071a7a7aa7ce7d5e74ce05036d8fe46df808b2e8e19f9454463c2e16c51f57b91

data/bin/tbgen

@@ -1,6 +1,3 @@
 #!/usr/bin/env ruby
-
-require_relative '../lib/compiler'
-compiler=VHDL_TB::Compiler.new
-compiler.analyze_options(ARGV)
-compiler.generate
+require_relative '../lib/runner'
+VHDL_TB::Runner.run(*ARGV)

data/bin/vhdl_tb

@@ -1,6 +1,3 @@
 #!/usr/bin/env ruby
-
-require_relative '../lib/compiler'
-generator=VHDL_TB::Compiler.new
-generator.analyze_options(ARGV)
-generator.generate
+require_relative '../lib/runner'
+VHDL_TB::Runner.run(*ARGV)

data/lib/ast.rb

@@ -1,5 +1,18 @@
 module VHDL_TB
-    Root=Struct.new(:design_units)
+    class AstNode
+    end
+
+    class Root < AstNode
+      attr_accessor :design_units
+      def initialize design_units=[]
+        @design_units=design_units
+      end
+
+      def << e
+        @design_units << e
+      end
+    end
+
     Entity=Struct.new(:name,:generics,:ports)
     Generic=Struct.new(:name,:type,:init)
     Input=Struct.new(:name,:type)
@@ -24,10 +37,27 @@ module VHDL_TB
       end
     end
 
+    class Expression < AstNode
+    end
 
-    Binary=Struct.new(:lhs,:op,:rhs) do
-      def to_s
-        "#{self.lhs} #{self.op} #{self.rhs}"
+    class Binary < Expression
+      attr_accessor :lhs,:op,:rhs
+      def initialize lhs=nil,op=nil,rhs=nil
+        @lhs,@op,@rhs=lhs,op,rhs
+      end
+    end
+
+    class FuncCall
+      attr_accessor :name,:actual_args
+      def initialize name=nil,args=[]
+        @name,@args=name,args
+      end
+    end
+
+    class Timed
+      attr_accessor :lhs,:rhs
+      def initialize lhs,rhs
+        @lhs,@rhs=lhs,rhs
       end
     end
 end

data/lib/compiler.rb

@@ -8,60 +8,37 @@ require_relative 'version'
 
 module VHDL_TB
 
-  TestBench=Struct.new(:name)
+ TestBench=Struct.new(:name)
 
  class Compiler
 
-   def initialize
-     #puts __dir__
-     banner
+   attr_accessor :options
+   attr_accessor :ast
+
+   def initialize options={}
      @engine=ERB.new(IO.read "#{__dir__}/template.tb.vhd")
-     @parser=Parser.new
    end
 
-   def banner
-     puts "==> VHDL testbench generator #{VERSION} <=="
+   def compile filename
+     puts "analyzing VHDL file : #{filename}"
+     @ast=Parser.new.parse filename
+     analyze filename
+     generate
    end
 
-   def analyze_options args
-     args << "-h" if args.empty?
-
-     opt_parser = OptionParser.new do |opts|
-       opts.banner = "Usage: vhdl_tb (or tbgen) <filename>"
-
-       opts.on("-v", "--version", "Prints version") do |n|
-         puts VERSION
-         abort
-       end
-
-       opts.on("-h", "--help", "Prints this help") do
-         puts "Generates testbench in VHDL, from a given file containing an Entity-Architecture couple."
-         puts
-         puts opts
-         abort
-       end
-     end
-
-     begin
-       opt_parser.parse!(args)
-       @args=args
-
-     rescue Exception => e
-       puts e
-       #puts e.backtrace
-       exit
-     end
+   def parse_2 filename
+     @ast=Parser.new.parse_2 filename
+     pp @ast
    end
 
-   def generate entity_filename=@args.first
+   def generate
      @symtable=[]
      @symtable << "clk"
      @symtable << "reset_n"
      @symtable << "sreset"
      begin
-       analyze(entity_filename)
        tb_txt=@engine.result(binding)
-       tb_filename="#{@tb.name}.vhd"
+       tb_filename="#{@tb.name}.vhd".downcase
        File.open(tb_filename,'w'){|f| f.puts tb_txt}
        puts "testbench generated : #{tb_filename}"
      rescue Exception => e
@@ -72,15 +49,11 @@ module VHDL_TB
    end
 
    def analyze entity_filename
-     puts "analyzing VHDL file : #{entity_filename}"
-
-     root=Parser.new.parse entity_filename
-
      #puts "parsed #{entity_filename}. Good."
-     @entity=root.design_units.find{|du| du.class==Entity}
+     @entity=ast.design_units.find{|du| du.class==Entity}
      puts "entity found        : #{@entity.name} (#{@entity.ports.size} ports)"
 
-     @arch=root.design_units.find{|du| du.is_a? Architecture}
+     @arch=ast.design_units.find{|du| du.is_a? Architecture}
      check
      # prepare ERB through instance variables
      @max_length=@entity.ports.map{|p| p.name.val.size}.max

data/lib/generic_parser.rb

@@ -18,8 +18,23 @@ class GenericParser
     end
   end
 
+  def maybe kind
+    if showNext.kind==kind
+      return acceptIt
+    end
+    nil
+  end
+
   def more?
     !tokens.empty?
   end
 
+  def lookahead n
+    showNext(k=n)
+  end
+
+  def niy
+    raise "NIY"
+  end
+
 end

data/lib/lexer.rb

@@ -65,6 +65,7 @@ module VHDL_TB
       keyword 'on'
       keyword 'open'
       keyword 'or'
+      keyword 'xor'
       keyword 'others'
       keyword 'out'
       keyword 'package'
@@ -93,6 +94,7 @@ module VHDL_TB
       keyword 'then'
       keyword 'to'
       keyword 'transport'
+      keyword 'time'
       keyword 'type'
       keyword 'unaffected'
       keyword 'units'
@@ -105,37 +107,48 @@ module VHDL_TB
       keyword 'with'
       keyword 'xnor'
       keyword 'xorkeyword '
+      keyword 'ns'
+      keyword 'ps'
+      keyword 'ms'
 
       #.............................................................
-      token :comment          => /\A\-\-(.*)$/
+      token :comment           => /\A\-\-(.*)$/
+
       token :selected_name     => /\w+(\.\w+)+/ # /\S+\w+\.\w+/
-      token :identifier        => /[a-zA-Z]\w*/
+      token :bit_string_literal => /([bB]|[oO]|[xX])"[^_]\w+"/
+      token :ident             => /[a-zA-Z]\w*/
 
       token :string_literal    => /"[^"]*"/
       token :char_literal      => /'(\w+)'/
       token :attribute_literal => /'(\w+)/
       token :decimal_literal   => /\d+(\.\d+)?(E([+-]?)\d+)?/
       token :based_literal     => /\d+#\w+(\.\w+)?#(E[+-]?\d+)/
-      token :bit_string_literal => /(b|o|x)"[^_]\w+"/
       token :vassign           => /\A\:\=/
+      token :sassign           => /\A\<\=/
       token :comma             => /\A\,/
       token :colon             => /\A\:/
       token :semicolon         => /\A\;/
       token :lparen            => /\A\(/
       token :rparen            => /\A\)/
-      token :plus              => /\A\+/
-      token :minus             => /\A\-/
-      token :times             => /\A\*/
+
+      # arith
+      token :add               => /\A\+/
+      token :sub               => /\A\-/
+      token :mul               => /\A\*/
       token :div               => /\A\//
 
-      token :sassign           => /\A\<\=/
       token :imply             => /\A\=\>/
+      # logical
       token :eq                => /\A\=/
-      token :ampersand         => /\A\&/
       token :neq               => /\A\/\=/
       token :gte               => /\A\>\=/
       token :gt                => /\A\>/
       token :lt                => /\A\</
+
+      token :sassign           => /\A\<\=/
+
+      token :ampersand         => /\A\&/
+
       token :urange            => /\A<>/
       token :dot               => /\A\./
       token :bar               => /\|/

data/lib/parser.rb

@@ -32,6 +32,31 @@ module VHDL_TB
       end
     end
 
+    def parse_2 filename
+      @tokens=lex(filename)
+      root=Root.new([])
+      while @tokens.any?
+        case showNext.kind
+        when :comment
+          root << acceptIt
+        when :library
+          root << parse_library
+        when :use
+          root << parse_use
+        when :entity
+          root << parse_entity
+        when :architecture
+          root << parse_architecture
+        when :package
+          root << parse_package
+        else
+          raise "got #{showNext}"
+          raise
+        end
+      end
+      root
+    end
+
     def parse filename
       @tokens=lex(filename)
       #pp @tokens
@@ -39,10 +64,8 @@ module VHDL_TB
       begin
         consume_to :entity
         root.design_units << entity=parse_entity
-
         consume_to :architecture
         root.design_units << archi=parse_architecture
-
       rescue Exception => e
         puts e.backtrace
         puts e
@@ -61,46 +84,63 @@ module VHDL_TB
       end
     end
 
+    def parse_library
+      expect :library
+      expect :ident
+      while showNext.is_a?(:comma)
+        acceptIt
+        expeact :ident
+      end
+      expect :semicolon
+    end
+
+    def parse_use
+      expect :use
+      expect :selected_name
+      expect :semicolon
+    end
+
     def parse_entity
       entity=Entity.new(nil,nil,[])
       expect :entity
-      entity.name=expect :identifier
+      entity.name=expect :ident
       expect :is
-      if showNext.is_a? :generic
-        entity.generics=parse_generics
-      end
+      parse_generics?
       if showNext.is_a? :port
         entity.ports=parse_ports
       end
       expect :end
+      maybe :ident
       if showNext.is_a? :semicolon
         acceptIt
       end
       return entity
     end
 
-    def parse_generics
-      generics=[]
-      expect :generic
-      expect :lparen
-      while showNext.is_not_a? :rparen
-        generics << parse_generic
-        if showNext.is_a? :semicolon
-          acceptIt
+    def parse_generics?
+      if showNext.is_a? :generic
+        generics=[]
+        expect :generic
+        expect :lparen
+        while showNext.is_not_a? :rparen
+          generics << parse_generic
+          if showNext.is_a? :semicolon
+            acceptIt
+          end
         end
+        expect :rparen
+        expect :semicolon
+        generics.flatten!
+        return generics
       end
-      expect :rparen
-      expect :semicolon
-      generics.flatten!
-      generics
     end
 
     def parse_generic
       ids=[]
-      ids << expect(:identifier)
+      ids << expect(:ident)
       while showNext.is_a? :comma
         acceptIt
-        ids << expect(:identifier)
+        ids << expect(:ident)
       end
       expect :colon
       type=parse_type
@@ -129,13 +169,13 @@ module VHDL_TB
 
     def parse_io
       ids=[]
-      ids << expect(:identifier)
+      ids << expect(:ident)
       while showNext.is_a? :comma
         acceptIt
-        ids << expect(:identifier)
+        ids << expect(:ident)
       end
       expect :colon
-      if showNext.is_a? [:in,:out]
+      if showNext.is_a? [:in,:out,:inout]
         dir=acceptIt
         dir=dir.kind
       end
@@ -146,8 +186,8 @@ module VHDL_TB
     def parse_type
       type=Identifier.new
       case showNext.kind
-      when :identifier
-        type.tok=expect(:identifier)
+      when :ident
+        type.tok=acceptIt
         if showNext.is_a? :lparen
           acceptIt
           name=type.tok
@@ -166,36 +206,686 @@ module VHDL_TB
       type
     end
 
+    def parse_architecture
+      archi=Architecture.new
+      expect :architecture
+      archi.name=expect(:ident)
+      expect :of
+      archi.entity=expect(:ident)
+      expect :is
+      parse_archi_decls
+      parse_archi_body
+      archi
+    end
+
+    def parse_archi_decls
+      parse_decls
+    end
+
+    def parse_decls
+      decls=[]
+      while showNext.kind!=:begin and showNext.kind!=:end
+        case showNext.kind
+        when :constant
+          decls << parse_constant
+        when :type
+          decls << parse_typedecl
+        when :signal
+          decls << parse_signal
+        when :procedure
+          decls << parse_procedure
+        when :function
+          decls << parse_function
+        when :component
+          decls << parse_component_decl
+        when :attribute
+          decls << parse_attribute
+        when :variable
+          decls << parse_variable
+        else
+          raise "ERROR : parse_decls #{pp showNext}"
+        end
+      end
+      decls
+    end
+
+    def parse_constant
+      expect :constant
+      expect :ident
+      while showNext.is_a?(:comma)
+        acceptIt
+        expect :ident
+      end
+      expect :colon
+      parse_type
+      initialized?
+      expect :semicolon
+    end
+
+    def parse_typedecl
+      expect :type
+      expect :ident
+      expect :is
+      case showNext.kind
+      when :lparen
+        acceptIt
+        expect :ident
+        while showNext.is_a?(:comma)
+          acceptIt
+          expect :ident
+        end
+        expect :rparen
+      when :record
+        parse_record
+      else
+        raise "parse_typedecl : #{pp showNext}"
+      end
+      expect :semicolon
+    end
+
+    def parse_record
+      expect :record
+      while showNext.not_a?(:end)
+        parse_record_item
+      end
+      expect :end
+      expect :record
+    end
+
+    def parse_record_item
+      expect :ident
+      while showNext.is_a?(:comma)
+        acceptIt
+        expect :ident
+      end
+      expect :colon
+      parse_type
+      expect :semicolon
+    end
+
+
+    def parse_signal
+      expect :signal
+      expect :ident
+      while showNext.is_a?(:comma)
+        acceptIt
+        expect :ident
+      end
+      expect :colon
+      parse_type
+      initialized?
+      expect :semicolon
+    end
+
+    def parse_procedure
+      expect :procedure
+      expect :ident
+      if showNext.is_a?(:lparen)
+        acceptIt
+        parse_formal_parameters
+        expect :rparen
+      end
+      expect :is
+      parse_decls
+      expect :begin
+      parse_body
+      expect :end
+      expect :procedure
+      expect :semicolon
+    end
+
+    def parse_formal_parameters
+      ret=[]
+      parse_formal_parameter
+      while showNext.is_a?(:comma)
+        acceptIt
+        ret << parse_formal_parameter
+      end
+      ret.flatten!
+      ret
+    end
+
+    def parse_formal_parameter
+      expect :ident
+      while showNext.is_a?(:comma)
+        acceptIt
+        expect :ident
+      end
+      expect :colon
+      parse_type
+    end
+
+    def parse_function
+      expect :function
+      expect :ident
+      if showNext.is_a?(:lparen)
+        acceptIt
+        parse_formal_parameters
+        expect :rparen
+      end
+
+      expect :return
+      parse_type
+
+      unless showNext.is_a?(:semicolon)
+        expect :is
+        parse_decls
+        expect :begin
+        parse_body
+        expect :end
+        maybe :function
+        maybe :ident
+      end
+      expect :semicolon
+    end
+
+    def parse_component_decl
+      expect :component
+      expect :ident
+      expect :is
+      parse_generics?
+      parse_ports
+      expect :end
+      expect :component
+      expect :semicolon
+    end
+
+    def parse_attribute
+      expect :attribute
+      expect :ident
+      case showNext.kind
+      when :colon #declaration
+        acceptIt
+        parse_type
+      when :of # specification
+        acceptIt
+        expect :ident
+        expect :colon
+        consume_to :semicolon
+      else
+        raise "ERROR : parse_attribute #{showNext}"
+      end
+      expect :semicolon
+    end
+
+    def parse_variable
+      expect :variable
+      expect :ident
+      while showNext.is_a?(:comma)
+        acceptIt
+        expect :ident
+      end
+      expect :colon
+      parse_type
+      expect :semicolon
+    end
+    #======================================
+    def parse_archi_body
+      expect :begin
+      while !showNext.is_a?(:end)
+        parse_concurrent_stmt
+      end
+      expect :end
+      expect :ident
+      expect :semicolon
+    end
+
+    def parse_concurrent_stmt
+      parse_label?
+      case showNext.kind
+      when :process
+        parse_process
+      when :entity
+        parse_entity_instanciation
+      when :ident
+        parse_assign
+      when :component
+        parse_component_instanciation
+      else
+        raise "parse_concurrent_stmt : #{pp showNext}"
+      end
+    end
+
+    def parse_label?
+      if lookahead(2).is_a?(:colon)
+        expect(:ident)
+        expect(:colon)
+      end
+    end
+
+    def parse_process
+      expect :process
+      if showNext.is_a?(:lparen)
+        parse_sensitivity_list
+      end
+      parse_decls
+      expect :begin
+      parse_body
+      expect :end
+      expect :process
+      expect :semicolon
+    end
+
+    def parse_sensitivity_list
+      expect :lparen
+      expect :ident
+      while showNext.is_a?(:comma)
+        acceptIt
+        expect :ident
+      end
+      expect :rparen
+    end
+
+    def parse_component_instanciation
+      expect :component
+      expect :ident
+      parse_generic_map?
+      parse_port_map
+      expect :semicolon
+    end
+
+    def parse_generic_map?
+      if showNext.is_a? :generic
+        acceptIt
+        expect :map
+        expect :lparen
+        while !showNext.is_a?(:rparen)
+          parse_assoc
+          if showNext.is_a?(:comma)
+            acceptIt
+          end
+        end
+        expect :rparen
+      end
+    end
+
+    def parse_entity_instanciation
+      expect :entity
+      expect :selected_name
+      if showNext.is_a?(:lparen)
+        acceptIt
+        expect :ident
+        expect :rparen
+      end
+      parse_generic_map?
+      parse_port_map
+      expect :semicolon
+    end
+
+    def parse_port_map
+      expect :port
+      expect :map
+      expect :lparen
+      while !showNext.is_a?(:rparen)
+        parse_assoc
+        if showNext.is_a?(:comma)
+          acceptIt
+        end
+      end
+      expect :rparen
+    end
+
+    def parse_assoc
+      expect :ident
+      expect :imply
+      if showNext.is_a?(:open)
+        acceptIt
+      else
+        parse_expression
+      end
+    end
+    #============== package
+
+    def parse_package
+      expect :package
+      case showNext.kind
+      when :ident
+        parse_package_decl
+      when :body
+        parse_package_body
+      else
+        raise "ERROR : parse_package"
+      end
+    end
+
+    def parse_package_decl
+      expect :ident
+      expect :is
+      while !showNext.is_a?(:end)
+        parse_decls
+      end
+      expect :end
+      maybe :package
+      expect :semicolon
+    end
+
+    def parse_package_body
+      expect :body
+      expect :ident
+      expect :is
+      while !showNext.is_a?(:end)
+        parse_decls
+      end
+      expect :end
+      expect :package
+      expect :body
+      expect :semicolon
+    end
+
+    #============== body
+    def parse_body
+      while !showNext.is_a?(:end) and !showNext.is_a?(:elsif) and !showNext.is_a?(:else) and !showNext.is_a?(:when)
+        parse_seq_stmt
+      end
+    end
+
+    def parse_seq_stmt
+      #puts "parse_seq_stmt line #{showNext.pos.first}"
+      case showNext.kind
+      when :null
+        parse_null_stmt
+      when :if
+        parse_if_stmt
+      when :for
+        parse_for
+      when :while
+        parse_while
+      when :case
+        parse_case
+      when :wait
+        parse_wait
+      when :report
+        parse_report
+      when :return
+        parse_return
+      when :ident,:selected_name
+        parse_assign
+      else
+        raise "ERROR : parse_seq_stmt : #{pp showNext}"
+      end
+    end
+
+    def parse_null_stmt
+      expect :null
+      expect :semicolon
+    end
+
+    def parse_assign
+      parse_term
+      if showNext.is_a? [:vassign,:sassign]
+        acceptIt
+      end
+
+      parse_expression
+
+      while showNext.is_a?(:comma)
+        acceptIt
+        parse_expression
+      end
+
+      while showNext.is_a?(:when)
+        got_when=true
+        acceptIt
+        parse_expression
+      end
+
+      if got_when
+        expect :else
+        parse_expression
+      end
+
+      expect :semicolon
+    end
+
+    def parse_if_stmt
+      expect :if
+      parse_expression
+      expect :then
+      parse_body
+      while showNext.is_a?(:elsif)
+        parse_elsif
+      end
+      if showNext.is_a?(:else)
+        acceptIt
+        parse_body
+      end
+      expect :end
+      expect :if
+      expect :semicolon
+    end
+
+    def parse_elsif
+      expect :elsif
+      parse_expression
+      expect :then
+      parse_body
+    end
+
+    def parse_for
+      expect :for
+      expect :ident
+      expect :in
+      parse_expression
+      if showNext.is_a? :to
+        expect :to
+        parse_expression
+      end
+      expect :loop
+      parse_body
+      expect :end
+      expect :loop
+      expect :semicolon
+    end
+
+    def parse_while
+      niy
+    end
+
+    def parse_case
+      expect :case
+      parse_expression
+      expect :is
+      while showNext.is_a? :when
+        parse_when_case
+      end
+      expect :end
+      expect :case
+      expect :semicolon
+    end
+
+    def parse_when_case
+      expect :when
+      parse_expression
+      expect :imply
+      parse_body
+    end
+
+    def parse_wait
+      expect :wait
+      case showNext.kind
+      when :until
+        acceptIt
+        parse_expression
+      when :for
+        acceptIt
+        parse_expression
+      when :semicolon
+      else
+        raise "parse_wait : #{pp showNext}"
+      end
+      expect :semicolon
+    end
+
+    def parse_report
+      expect :report
+      parse_expression
+      expect :semicolon
+    end
+
+    def parse_return
+      expect :return
+      parse_expression
+      expect :semicolon
+    end
+
+    # ============================= expression ===============================
+    COMPARISON_OP=[:eq,:neq,:gt,:gte,:lt,:lte]
     def parse_expression
-      e1=parse_term
-      while showNext.is_a? [:plus,:minus,:times,:div]
+      t1=parse_additive
+      while more? && showNext.is_a?(COMPARISON_OP)
         op=acceptIt
-        e2=parse_term
-        e1=Binary.new(e1,op,e2)
+        t2=parse_additive
+        t1=Binary.new(t1,op,t2)
+      end
+      return t1
+    end
+
+    ADDITIV_OP  =[:add,:sub, :or, :xor] #xor ?
+    def parse_additive
+      t1=parse_multiplicative
+      while more? && showNext.is_a?(ADDITIV_OP)
+        op=acceptIt #full token
+        t2=parse_multiplicative
+        t1=Binary.new(t1,op,t2)
       end
-      return e1
+      return t1
+    end
+
+    MULTITIV_OP=[:mul,:div,:mod,:and,:shiftr,:shiftl]
+    def parse_multiplicative
+      t1=parse_term
+      while more? && showNext.is_a?(MULTITIV_OP)
+        op=acceptIt
+        t2=parse_term
+        t1=Binary.new(t1,op,t2)
+      end
+      return t1
     end
 
     def parse_term
-      if showNext.is_a? [:decimal_literal,:identifier]
+      if showNext.is_a? [:ident,:selected_name,:decimal_literal,:char_literal,:string_literal,:bit_string_literal,:lparen,:others,:not,:sub]
         case showNext.kind
+        when :ident
+          ret=Identifier.new(acceptIt)
+        when :lparen
+          ret=parse_parenth
+        when :not
+          ret=parse_unary
         when :decimal_literal
-          return IntLit.new(acceptIt)
-        when :identifier
-          return Identifier.new(acceptIt)
+          ret=IntLit.new(acceptIt)
+        when :char_literal
+          ret=acceptIt
+        when :string_literal,:bit_string_literal
+          ret=acceptIt
+        when :selected_name
+          ret=acceptIt
+        when :others
+          ret=acceptIt
         else
-          puts "cannot parse term"
+          puts "cannot parse term : #{showNext}"
+        end
+      end
+      while showNext && showNext.is_a?([:lbrack,:attribute_literal,:lparen,:ns,:ps,:ms,:after,:ampersand])
+        if par=parenthesized?
+          #par.name=ret
+          ret=par
+        elsif attribute=attributed?
+          #attribute.lhs=ret
+          ret=attribute
+        elsif timed=timed?
+          timed.lhs=ret
+          ret=timed
+        elsif after=after?
+          #after.lhs=ret
+          ret=after
+        elsif concat=concat?
+          ret=concat
         end
       end
+      ret
     end
 
-    def parse_architecture
-      archi=Architecture.new
-      expect :architecture
-      archi.name=expect(:identifier)
-      expect :of
-      archi.entity=expect(:identifier)
-      archi
+    # parenthesized expressions (NOT indexed or funcall)
+    def parse_parenth
+      expect :lparen
+      if showNext.is_a?(:others) # e.g : (others=>'0')
+        acceptIt
+        expect :imply
+        parse_expression
+      else
+        parse_expression
+      end
+
+      while showNext.is_a?(:comma) # aggregate
+        acceptIt
+        parse_expression
+      end
+      expect :rparen
+    end
+
+    def parse_unary
+      if showNext.is_a?([:not,:sub])
+        acceptIt
+        parse_expression
+      end
+    end
+
+    def timed?
+      if showNext.is_a? [:ps,:ns,:ms]
+        tok=acceptIt
+        ret=Timed.new(nil,tok)
+      end
+    end
+
+    def parenthesized?
+      if showNext.is_a? :lparen
+        acceptIt
+        ret=FuncCall.new
+        args=[]
+        while !showNext.is_a? :rparen
+          args << parse_expression()
+          while showNext.is_a? :comma
+            acceptIt
+            args << parse_expression()
+          end
+          if showNext.is_a? [:downto,:to] #slice !
+            acceptIt
+            parse_expression
+          end
+        end
+        expect :rparen
+        ret.actual_args = args
+      else
+        return false
+      end
+      return ret
+    end
+
+    def initialized?
+      if showNext.is_a?(:vassign)
+        acceptIt
+        parse_expression
+      end
+    end
+
+    def after?
+      if showNext.is_a?(:after)
+        acceptIt
+        parse_expression
+      end
+    end
+
+    def concat?
+      if showNext.is_a?(:ampersand)
+        acceptIt
+        parse_expression
+      end
+    end
+
+    def attributed?
+      if showNext.is_a?(:attribute_literal)
+        acceptIt
+      end
     end
   end
 end

data/lib/runner.rb

@@ -0,0 +1,89 @@
+require "optparse"
+
+require_relative "compiler"
+
+module VHDL_TB
+
+  class Runner
+
+    def self.run *arguments
+      new.run(arguments)
+    end
+
+    def run arguments
+      compiler=Compiler.new
+      compiler.options = args = parse_options(arguments)
+      if args[:parse_only]
+        filename=args[:vhdl_file]
+        compiler.parse_2 filename
+      elsif filename=args[:vhdl_file]
+        compiler.compile filename
+      else
+        puts "need a VHDL file : vhdl_tb [options] <file.vhd>"
+      end
+    end
+
+    def header
+      puts "VHDL utilities (#{VERSION})- (c) JC Le Lann 2016-20"
+    end
+
+    private
+    def parse_options(arguments)
+      header
+
+      parser = OptionParser.new
+
+      no_arguments=arguments.empty?
+
+      options = {}
+
+      parser.on("-h", "--help", "Show help message") do
+        puts parser
+        exit(true)
+      end
+
+      parser.on("-p", "--parse", "parse only") do
+        options[:parse_only]=true
+      end
+
+      parser.on("--pp", "pretty print back source code ") do
+        options[:pp] = true
+      end
+
+      parser.on("--ast", "abstract syntax tree (AST)") do
+        options[:ast] = true
+      end
+
+      parser.on("--check", "elaborate and check types") do
+        options[:check] = true
+      end
+
+      parser.on("--draw_ast", "draw abstract syntax tree (AST)") do
+        options[:draw_ast] = true
+      end
+
+      parser.on("--dummy_transform", "dummy ast transform") do
+        options[:dummy_transform] = true
+      end
+
+      parser.on("--vv", "verbose") do
+        options[:verbose] = true
+      end
+
+      parser.on("-v", "--version", "Show version number") do
+        puts VERSION
+        exit(true)
+      end
+
+      parser.parse!(arguments)
+
+      options[:vhdl_file]=arguments.shift #the remaining c file
+
+      if no_arguments
+        puts parser
+      end
+
+      options
+    end
+  end
+end

data/lib/token.rb

@@ -18,6 +18,11 @@ class Token
     end
   end
 
+  def not_a? kind
+    result=self.is_a? kind
+    !result
+  end
+
   def is_not_a? kind
     case kind
     when Symbol

data/lib/version.rb

@@ -1,3 +1,3 @@
 module VHDL_TB
-  VERSION="0.7.7"
+  VERSION="0.8.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vhdl_tb
 version: !ruby/object:Gem::Version
-  version: 0.7.7
+  version: 0.8.2
 platform: ruby
 authors:
 - Jean-Christophe Le Lann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-27 00:00:00.000000000 Z
+date: 2020-04-21 00:00:00.000000000 Z
 dependencies: []
 description: A simple testbench generator for VHDL
 email: jean-christophe.le_lann@ensta-bretagne.fr
@@ -26,6 +26,7 @@ files:
 - lib/generic_parser.rb
 - lib/lexer.rb
 - lib/parser.rb
+- lib/runner.rb
 - lib/template.tb.vhd
 - lib/token.rb
 - lib/version.rb