flgen 0.14.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0c98696eca3ffddc4f49695ec9fe26ad40bebaa8b4ef432a9a24455059ec675f
+  data.tar.gz: 2d4cacf96065ceeebf2c5a662fd0d2f2706e9fb97363a3990eec9e77d06d1ad8
+SHA512:
+  metadata.gz: '065852d3c973c0a108e1fccaea7cf7219e9c734fe9f75adff152ddd05df406fe8cb3d92a1a6281bf5494b22d279c60b7d69ba2eec0a104fcfe6a6badbda1dcfe'
+  data.tar.gz: 70eb64d338dad8169c3a577228b4640fa91c4e5645aa8432401996aa95696a53cca8d5d0e2d1b01568e0a7082b1a00fd0692a4650c508a9945cf56e420d1429a

data/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,146 @@
+[![CI](https://github.com/pezy-computing/flgen/actions/workflows/ci.yml/badge.svg)](https://github.com/pezy-computing/flgen/actions/workflows/ci.yml)
+
+# FLGen
+
+ファイルリストを記述するための DSL と、ファイルリストを生成するための実行コマンドを提供します。
+
+## インストール
+
+### Ruby
+
+FLGen は [Ruby](https://www.ruby-lang.org) で実装されているので、実行には Ruby のインストールが必要です。
+サポートする Ruby のバージョンは 3.0 以上です。インストール方法については、[こちら](https://www.ruby-lang.org/en/downloads/)を参照ください。
+
+### インストールコマンド
+
+FLGen をインストールするには、以下のコマンドを実行します。
+
+```
+$ gem install flgen
+```
+
+## DSL
+
+ファイルリストを記述するための DSL として以下の構文が定義されています。
+
+* `source_file(path, from: :current)`
+    * 指定したファイルをファイルリストに追加します
+* `file_list(path, from: :root)`
+    * 指定したファイルリストを読み込みます
+* `define_macro(name, value = nil)`
+    * マクロを定義します
+* `macro_defined?(name)`
+    * 指定したマクロが定義されているかどうかを返します
+* `include_directory(path, from: :current)`
+    * 指定したパスをインクルードパスとして追加します
+* `target_tool?(tool)`
+    * `tool` が対象ツールかどうかを返します
+* `compile_argument(argument, tool: nil)`
+    * コンパイル引数を追加します
+    * `tool` が指定されている場合は、対象ツールの場合にのみ、引数を追加します
+* `runtime_argument(argument, tool: nil)`
+    * 実行時引数を追加します
+    * `tool` が指定されている場合は、対象ツールの場合にのみ、引数を追加します
+
+Ruby の言語内 DSL として実装されているので、以下の様に `if` など Ruby の構文も使用することができます。
+
+```ruby
+if target_tool? :vcs
+  compile_argument '-sverilog'
+end
+
+10.times do |i|
+  source_file "foo_#{i}.sv"
+end
+```
+
+### `from` オプション引数について
+
+`from` は指定されたファイルやディレクトリの基準ディレクトリを指定する引数で、`:current`/`root`/`local_root` を指定することができます。
+
+* `:current`
+    * 現在のファイルリストがある場所を基準とします
+* `:root`
+    * `.git` があるリポジトリのルートディレクトリを基準ディレクトリとします
+    * あるリポジトリのサブモジュール (上位階層にも `.git` がある) 場合、上位リポジトリのルートディレクトリから順に検索を行います
+* `:local_root`
+    * 自身が含まれるリポジトリのルートディレクトリを基準ディレクトリとします
+
+ただし、与えられたファイルやディレクトリが絶対パスで指定されている場合は、`from` に関係なく、そのまま追加されます。
+
+#### 例
+
+以下のディレクトリ構造になっていたとします。
+
+```
+foo_project
++-- .git
++-- bar_project
+|   +-- .git
+|   +-- common
+|   |   `-- common.sv
+|   `-- src
+|       + bar.list.rb
+|       ` bar.sv
+`-- common
+    `-- common.sv
+```
+
+* `bar.list.rb` で `source_file 'bar.sv', from: :current` とある場合
+    * `foo_project/bar_project/src/bar.sv` が追加される
+* `bar.list.rb` で `source_file 'common/common.sv', from: :root` とある場合
+    * `foo_project/common/common.sv` が追加される
+* `bar.list.rb` で `source_file 'common/common.sv', from: :local_root` とある場合
+    * `foo_project/bar_project/common/common.sv` が追加される
+
+## 実行コマンド
+
+`flgen` が実行コマンドです。`flgen` に DSL で記述されたファイルリストを与えると、EDA ツールに与えるためのファイルリストを出力します。
+また、以下のオプションがあります。
+
+* `--define-macro=MACRO[,MACRO]`
+    * マクロ定義を追加します
+* `--include-directory=DIR[,DIR]`
+    * インクルードディレクトリを追加します
+* `--compile`
+    * 出力されるファイルリストは `runtime_argument` で指定された実行時引数を含みません
+* `--runtime`
+    * 出力されるファイルリストは `runtime_argument` で指定された実行時引数だけを含みます
+* `--tool=TOOL`
+    * 対象となる EDA ツールを指定します
+    * `compile_argument`/`runtime_argument` でツールの指定がある場合、一致する引数がファイルリストに出力されます
+* `--rm-ext=EXT[,EXT]`
+    * 指定された拡張子をソースファイルから削除します
+* `--collect-ext=EXT[,EXT]`
+    * 指定された拡張子を持つソースファイルのみがファイルリストに出力されます
+* `--output=FILE`
+    * 出力するファイルリストのファイル名を指定します
+    * 指定がない場合は、標準出力に出力されます
+* `--[no-]print-header`
+    * ヘッダーを出力するかどうかを指定します。
+* `--source-file-only`
+    * ソースファイルのみがファイルリストに出力されます
+
+## サンプル
+
+https://github.com/pezy-computing/flgen/tree/master/sample
+
+にサンプルがあります。
+
+## ライセンス
+
+Apache-2.0 ライセンスの元で公開しています。詳しくは、下記及び [LICENSE](LICENSE) を参照ください。
+
+    Copyright 2022 PEZY Computing K.K.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.

data/exe/flgen

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'flgen'
+
+begin
+  FLGen::CLI.new.run(ARGV)
+rescue FLGen::FLGenError => e
+  abort e.to_s
+end

data/lib/flgen/arguments.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module FLGen
+  module Arguments
+    class Base
+      def initialize(type, tool)
+        @type = type
+        @tool = tool
+      end
+
+      attr_reader :type
+      attr_reader :tool
+
+      def match_tool?(target_tool)
+        tool.nil? || target_tool && (tool == target_tool) || false
+      end
+    end
+
+    class Define < Base
+      def initialize(name, value)
+        super(:define, nil)
+        @name = name
+        @value = value
+      end
+
+      attr_reader :name
+      attr_reader :value
+    end
+
+    class Include < Base
+      def initialize(path)
+        super(:include, nil)
+        @path = path
+      end
+
+      attr_reader :path
+    end
+
+    class Generic < Base
+      def initialize(argument, tool)
+        super(:generic, tool)
+        @argument = argument
+      end
+
+      attr_reader :argument
+    end
+  end
+end

data/lib/flgen/cli.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module FLGen
+  class CLI
+    PROGRAM_NAME = 'flgen'
+
+    def run(args)
+      options, remain_args = parse_options(args.dup)
+      context = parse_file_list(options, remain_args)
+      output_result(args, context)
+    end
+
+    private
+
+    def parse_options(args)
+      options = {
+        macros: [], include_directories: [], runtime: false, tool: nil,
+        rm_ext: [], collect_ext: [], format: :filelist, print_header: true,
+        source_file_only: false
+      }
+      option_parser(options).parse!(args)
+      [options, args]
+    end
+
+    def option_parser(options)
+      OptionParser.new do |parser|
+        parser.version = VERSION
+        parser.program_name = PROGRAM_NAME
+
+        parser.on('--define-macro=MACRO[,MACRO]', Array) do |macros|
+          options[:macros].concat(macros)
+        end
+        parser.on('--include-directory=DIR[,DIR]', Array) do |directories|
+          options[:include_directories].concat(directories)
+        end
+        parser.on('--compile') do
+          options[:runtime] = false
+        end
+        parser.on('--runtime') do
+          options[:runtime] = true
+        end
+        parser.on('--tool=TOOL') do |tool|
+          options[:tool] = tool.to_sym
+        end
+        parser.on('--rm-ext=EXT[,EXT]', Array) do |ext|
+          options[:rm_ext].concat(ext)
+        end
+        parser.on('--collect-ext=EXT[,EXT]', Array) do |ext|
+          options[:collect_ext].concat(ext)
+        end
+        parser.on('--format=FORMAT') do |format|
+          options[:format] = format.to_sym
+        end
+        parser.on('--output=FILE') do |file|
+          options[:output] = file
+        end
+        parser.on('--[no-]print-header') do |value|
+          options[:print_header] = value
+        end
+        parser.on('--source-file-only') do |value|
+          options[:source_file_only] = value
+        end
+      end
+    end
+
+    def parse_file_list(options, args)
+      context = create_context(options)
+      top_level = FileList.new(context, '')
+      args.each { |arg| load_file_list(top_level, arg) }
+      context
+    end
+
+    def create_context(options)
+      context = Context.new(options)
+      context
+        .options[:macros]
+        .each(&context.method(:define_macro))
+      context
+        .options[:include_directories]
+        .each(&context.method(:add_include_directory))
+      context
+    end
+
+    def load_file_list(top_level, arg)
+      path = File.expand_path(arg)
+      top_level.file_list(path)
+    end
+
+    def output_result(args, context)
+      formatter = create_formatter(context)
+      print_header(context, formatter, args)
+      if context.options[:output]
+        File.open(context.options[:output], 'w') { |io| formatter.output(io) }
+      else
+        formatter.output($stdout)
+      end
+    end
+
+    def create_formatter(context)
+      formatter = Formatter.formatters[context.options[:format]]
+      formatter.new(context)
+    end
+
+    def print_header(_context, formatter, args)
+      formatter.header_lines << "#{PROGRAM_NAME} version #{FLGen::VERSION}"
+      formatter.header_lines << 'applied arguments'
+      args.each do |arg|
+        formatter.header_lines << "  #{arg}"
+      end
+    end
+  end
+end

data/lib/flgen/context.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module FLGen
+  class Context
+    def initialize(options)
+      @options = options
+    end
+
+    attr_reader :options
+
+    def source_files
+      @source_files ||= []
+    end
+
+    def add_source_file(root, path)
+      return if runtime?
+
+      file = SourceFile.new(root, path)
+      add_source_file?(file) &&
+        (source_files << file.remove_ext(@options[:rm_ext]))
+    end
+
+    def define_macro(macro, value = nil)
+      k, v =
+        if value.nil? && macro.respond_to?(:split)
+          macro.split('=', 2)
+        else
+          [macro, value]
+        end
+      add_macro_definition(k.to_sym, v)
+    end
+
+    def macros
+      @macros ||= []
+    end
+
+    def add_include_directory(directory)
+      return if include_directory_already_added?(directory)
+
+      add_compile_argument(Arguments::Include.new(directory))
+    end
+
+    def add_compile_argument(argument)
+      return if runtime?
+
+      add_argument(argument)
+    end
+
+    def add_runtime_argument(argument)
+      return unless runtime?
+
+      add_argument(argument)
+    end
+
+    def arguments
+      @arguments ||= []
+    end
+
+    def loaded_file_lists
+      @loaded_file_lists ||= []
+    end
+
+    private
+
+    def runtime?
+      options[:runtime]
+    end
+
+    def add_source_file?(file)
+      target_ext?(file) && !source_file_already_added?(file)
+    end
+
+    def target_ext?(file)
+      return true unless @options.key?(:collect_ext)
+      return true if @options[:collect_ext].empty?
+
+      file.match_ext?(@options[:collect_ext])
+    end
+
+    def source_file_already_added?(file)
+      checksum = file.checksum
+      path = file.path
+
+      return true if checksums[path].include?(checksum)
+
+      checksums[path] << checksum
+      false
+    end
+
+    def checksums
+      @checksums ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def add_macro_definition(name, value)
+      macros << name unless macros.include?(name)
+      arguments
+        .delete_if { |argument| argument.type == :define && argument.name == name }
+      add_compile_argument(Arguments::Define.new(name, value))
+    end
+
+    def include_directory_already_added?(path)
+      arguments
+        .any? { |argument| argument.type == :include && argument.path == path }
+    end
+
+    def add_argument(argument)
+      return unless argument.match_tool?(options[:tool])
+
+      arguments << argument
+    end
+  end
+end

data/lib/flgen/exceptions.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FLGen
+  class FLGenError < StandardError
+  end
+
+  class NoEntryError < FLGenError
+    def initialize(path, location)
+      message =
+        "no such file or directory -- #{path} " \
+        "@#{location.path}:#{location.lineno}"
+      super(message)
+    end
+  end
+end

data/lib/flgen/file_list.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module FLGen
+  class FileList
+    def initialize(context, path)
+      @context = context
+      @path = path
+      @root_directories = extract_root
+    end
+
+    def file_list(path, from: :root, raise_error: true)
+      root = find_root(path, from, :file?)
+      load_file_list(root, path, raise_error)
+    end
+
+    def source_file(path, from: :current, raise_error: true)
+      root = find_root(path, from, :file?)
+      add_source_file(root, path, raise_error)
+    end
+
+    def define_macro(macro, value = nil)
+      @context.define_macro(macro, value)
+    end
+
+    def macro_defined?(macro)
+      @context.macros.include?(macro.to_sym)
+    end
+
+    def include_directory(path, from: :current, raise_error: true)
+      root = find_root(path, from, :directory?)
+      add_include_directory(root, path, raise_error)
+    end
+
+    def target_tool?(tool)
+      target_tool = @context.options[:tool]
+      target_tool && tool.to_sym == target_tool || false
+    end
+
+    def compile_argument(argument, tool: nil)
+      @context.add_compile_argument(Arguments::Generic.new(argument, tool))
+    end
+
+    def runtime_argument(argument, tool: nil)
+      @context.add_runtime_argument(Arguments::Generic.new(argument, tool))
+    end
+
+    private
+
+    def extract_root
+      return nil if @path.empty?
+
+      Pathname
+        .new(@path)
+        .dirname
+        .descend
+        .select(&method(:repository_root?))
+        .map(&:to_s)
+    end
+
+    def repository_root?(path)
+      File.exist?(path.join('.git').to_s)
+    end
+
+    def find_root(path, from, checker)
+      if absolute_path?(path)
+        ''
+      elsif from == :current
+        current_directory
+      else
+        lookup_root(path, from, checker)
+      end
+    end
+
+    def absolute_path?(path)
+      Pathname.new(path).absolute?
+    end
+
+    def current_directory
+      # From Ruby 3.1 Thread::Backtrace::Location#absolute_path returns nil
+      # for code string evaluated by eval methods
+      # see https://github.com/ruby/ruby/commit/64ac984129a7a4645efe5ac57c168ef880b479b2
+      location = caller_locations(3, 1).first
+      path = location.absolute_path || location.path
+      File.dirname(path)
+    end
+
+    def lookup_root(path, from, checker)
+      (from == :root && @root_directories || [@root_directories.last])
+        .find { |root| File.__send__(checker, File.join(root, path)) }
+    end
+
+    def load_file_list(root, path, raise_error)
+      entry_exist?(root, path, :file?, raise_error) || return
+
+      # Need to File.realpath to resolve symblic link
+      list_path = File.realpath(concat_path(root, path))
+      file_list_already_loaded?(list_path) && return
+
+      @context.loaded_file_lists << list_path
+      self.class.new(@context, list_path)
+        .instance_eval(File.read(list_path), list_path)
+    end
+
+    def file_list_already_loaded?(path)
+      @context.loaded_file_lists.include?(path)
+    end
+
+    def add_source_file(root, path, raise_error)
+      entry_exist?(root, path, :file?, raise_error) || return
+      @context.add_source_file(root, path)
+    end
+
+    def add_include_directory(root, path, raise_error)
+      entry_exist?(root, path, :directory?, raise_error) || return
+
+      directory_path = concat_path(root, path)
+      @context.add_include_directory(directory_path)
+    end
+
+    def entry_exist?(root, path, checker, raise_error)
+      result = root && File.__send__(checker, concat_path(root, path)) || false
+      result ||
+        raise_error && (raise NoEntryError.new(path, caller_locations(3, 1)[0]))
+    end
+
+    def concat_path(root, path)
+      File.expand_path(path, root)
+    end
+  end
+end

data/lib/flgen/file_list_formatter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FLGen
+  class FileListFormatter < Formatter
+    def format_header_line(line)
+      "//  #{line}"
+    end
+
+    def format_macro(macro, value)
+      if value.nil?
+        "+define+#{macro}"
+      else
+        "+define+#{macro}=#{value}"
+      end
+    end
+
+    def format_include_directory(directory)
+      "+incdir+#{directory}"
+    end
+
+    def fomrat_argument(argument)
+      argument
+    end
+
+    def format_file_path(path)
+      path
+    end
+
+    Formatter.add_formatter(:filelist, self)
+  end
+end

data/lib/flgen/formatter.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module FLGen
+  class Formatter
+    class << self
+      def add_formatter(type, formatter)
+        formatters[type] = formatter
+      end
+
+      def formatters
+        @formatters ||= {}
+      end
+    end
+
+    def initialize(context)
+      @context = context
+      @header_lines = []
+    end
+
+    attr_reader :header_lines
+
+    def output(io)
+      print_header(io)
+      print_macros(io)
+      print_include_directoris(io)
+      print_arguments(io)
+      print_source_files(io)
+    end
+
+    private
+
+    def print_header(io)
+      return unless print_header?
+
+      header_lines.each do |line|
+        io.puts(format_header_line(line))
+      end
+    end
+
+    def print_header?
+      @context.options[:output] &&
+        @context.options[:print_header] && !@context.options[:source_file_only]
+    end
+
+    def each_argument(type, &block)
+      @context.arguments.each do |argument|
+        argument.type == type && block.call(argument)
+      end
+    end
+
+    def print_macros(io)
+      return if source_file_only?
+
+      pre_macros(io)
+      each_argument(:define) do |argument|
+        io.puts(format_macro(argument.name, argument.value))
+      end
+      post_macros(io)
+    end
+
+    def pre_macros(_io)
+    end
+
+    def post_macros(_io)
+    end
+
+    def print_include_directoris(io)
+      return if source_file_only?
+
+      pre_include_directories(io)
+      each_argument(:include) do |argument|
+        io.puts(format_include_directory(argument.path))
+      end
+      post_include_directories(io)
+    end
+
+    def pre_include_directories(_io)
+    end
+
+    def post_include_directories(_io)
+    end
+
+    def print_arguments(io)
+      return if source_file_only?
+
+      pre_arguments(io)
+      each_argument(:generic) do |argument|
+        io.puts(fomrat_argument(argument.argument))
+      end
+      post_arguments(io)
+    end
+
+    def pre_arguments(io)
+    end
+
+    def post_arguments(io)
+    end
+
+    def source_file_only?
+      @context.options[:source_file_only]
+    end
+
+    def print_source_files(io)
+      pre_source_files(io)
+      @context.source_files.each do |file|
+        io.puts(format_file_path(file.full_path))
+      end
+      post_source_files(io)
+    end
+
+    def pre_source_files(_io)
+    end
+
+    def post_source_files(_io)
+    end
+  end
+end

data/lib/flgen/source_file.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FLGen
+  class SourceFile
+    def initialize(root, path)
+      @root = root
+      @path = path
+    end
+
+    attr_reader :root
+    attr_reader :path
+
+    def full_path
+      File.join(@root, @path)
+    end
+
+    def match_ext?(ext_list)
+      return false if ext_list.nil? || ext_list.empty?
+
+      file_ext = File.extname(@path)
+      ext_list.any? do |ext|
+        (ext[0] == '.' && ext || ".#{ext}") == file_ext
+      end
+    end
+
+    def remove_ext(ext_list)
+      return self unless match_ext?(ext_list)
+
+      path = Pathname.new(@path).sub_ext('').to_s
+      self.class.new(@root, path)
+    end
+
+    def checksum
+      @checksum ||= Digest::MD5.digest(File.read(full_path))
+    end
+  end
+end

data/lib/flgen/version.rb

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

data/lib/flgen.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'digest/md5'
+require 'optparse'
+require 'pathname'
+require_relative 'flgen/version'
+require_relative 'flgen/exceptions'
+require_relative 'flgen/source_file'
+require_relative 'flgen/arguments'
+require_relative 'flgen/file_list'
+require_relative 'flgen/context'
+require_relative 'flgen/formatter'
+require_relative 'flgen/file_list_formatter'
+require_relative 'flgen/cli'

data/sample/bar/bar.list.rb

@@ -0,0 +1,6 @@
+define_macro :BAR_0
+define_macro :BAR_1, 1
+compile_argument '-bar_0', tool: :vcs
+runtime_argument '-bar_1', tool: :vcs
+source_file 'sample/bar/bar.sv', from: :root
+file_list   'baz/baz.list.rb', from: :current

data/sample/bar/bar.sv

@@ -0,0 +1,2 @@
+module bar;
+endmodule

data/sample/bar/baz/baz.list.rb

@@ -0,0 +1,8 @@
+include_directory '.'
+if target_tool? :xcelium
+  compile_argument '-baz_0'
+  runtime_argument '-baz_1'
+end
+unless macro_defined? :NO_BAZ
+  source_file 'baz.sv'
+end

data/sample/bar/baz/baz.sv

@@ -0,0 +1,2 @@
+module baz;
+endmodule

data/sample/foo.list.rb

@@ -0,0 +1,5 @@
+compile_argument '-foo_0'
+runtime_argument '-foo_1'
+include_directory 'bar'
+source_file 'foo.sv'
+file_list   'sample/bar/bar.list.rb'

data/sample/foo.sv

@@ -0,0 +1,2 @@
+module foo;
+endmodule

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: flgen
+version: !ruby/object:Gem::Version
+  version: 0.14.0
+platform: ruby
+authors:
+- Taichi Ishitani
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.12.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.40.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.40.0
+description: Filelist generator
+email:
+- ishitani@pezy.co.jp
+executables:
+- flgen
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/flgen
+- lib/flgen.rb
+- lib/flgen/arguments.rb
+- lib/flgen/cli.rb
+- lib/flgen/context.rb
+- lib/flgen/exceptions.rb
+- lib/flgen/file_list.rb
+- lib/flgen/file_list_formatter.rb
+- lib/flgen/formatter.rb
+- lib/flgen/source_file.rb
+- lib/flgen/version.rb
+- sample/bar/bar.list.rb
+- sample/bar/bar.sv
+- sample/bar/baz/baz.list.rb
+- sample/bar/baz/baz.sv
+- sample/foo.list.rb
+- sample/foo.sv
+homepage: https://github.com/pezy-computing/flgen
+licenses:
+- Apache-2.0
+metadata:
+  bug_tracker_uri: https://github.com/pezy-computing/flgen/issues
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/pezy-computing/flgen
+  wiki_uri: https://github.com/pezy-computing/flgen/wiki
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key: 
+specification_version: 4
+summary: Filelist generator
+test_files: []