dc_args.f90

Go to the documentation of this file.

!-----------------------------------------------------------------------
! Copyright (c) 2000-2026 Gtool Development Group. All rights reserved.
!-----------------------------------------------------------------------
!>
!> @author    Youhei SASAKI, Yasuhiro MORIKAWA
!> @copyright Copyright (C) GFD Dennou Club, 2005-2026. All rights reserved. <br/>
!>            License is BSD-2-Clause. see [COPYRIGHT](@ref COPYRIGHT) in detail
!> @en
!> @brief Command line arguments parser
!> @details
!> This module parses command line arguments.
!>
!> In addition, convenient subroutines for displaying help messages
!> are provided.
!>
!> @section args_tutorial Tutorial
!>
!> - gtool5 Official Tutorial:
!>   @ref tutorial_dc_args "Command Line Arguments Parsing"
!>
!> @section args_procedures Procedures list
!>
!> | Procedure      | Description                                              |
!> |----------------|----------------------------------------------------------|
!> | DCArgsOpen     | Initialize ARGS derived type variable                    |
!> | DCArgsClose    | Finalize ARGS derived type variable                      |
!> | DCArgsGet      | Get command line arguments                               |
!> | DCArgsNumber   | Return number of command line arguments                  |
!> | DCArgsOption   | Configure for getting command line option                |
!> | DCArgsDebug    | Auto-configure debug option                              |
!> | DCArgsHelp     | Auto-configure help option                               |
!> | DCArgsHelpMsg  | Configure help message                                   |
!> | DCArgsStrict   | Configure to show warning when invalid option is given   |
!> | DCArgsPutLine  | Print contents of ARGS derived type variable             |
!>
!> @enden
!>
!> @ja
!> @brief コマンドライン引数の解析
!> @details
!> コマンドライン引数の解析を行います.
!>
!> 加えて, ヘルプメッセージの表示に関して便利なサブルーチンも
!> 用意しています.
!>
!> @section args_tutorial_ja チュートリアル
!>
!> - gtool5 オフィシャルチュートリアル:
!>   @ref tutorial_dc_args "コマンドライン引数の解析"
!>
!> @section args_procedures_ja 手続一覧
!>
!> | 手続名         | 説明                                                     |
!> |----------------|----------------------------------------------------------|
!> | DCArgsOpen     | 構造型 ARGS 変数の初期化                                 |
!> | DCArgsClose    | 構造型 ARGS 変数の終了処理                               |
!> | DCArgsGet      | コマンドライン引数の取得                                 |
!> | DCArgsNumber   | コマンドライン引数の数を返す                             |
!> | DCArgsOption   | コマンドライン引数オプションを取得するための設定         |
!> | DCArgsDebug    | デバッグオプションの自動設定                             |
!> | DCArgsHelp     | ヘルプオプションの自動設定                               |
!> | DCArgsHelpMsg  | ヘルプメッセージの設定                                   |
!> | DCArgsStrict   | 無効なオプションが指定された時に警告を表示するよう設定   |
!> | DCArgsPutLine  | 構造型 ARGS 変数の内容を印字                             |
!>
!> @section args_usage_ja 使用方法
!>
!> 構造型 ARGS の変数を定義し, Open, Get を利用することで
!> コマンドライン引数を取得することができます.
!>
!> @code{.f90}
!> program dc_args_sample1
!>   use dc_types
!>   use dc_string, only: StoA
!>   use dc_args
!>   implicit none
!>   type(ARGS) :: arg
!>   character(STRING), pointer :: argv(:) => null()
!>   integer :: i
!>
!>   call DCArgsOpen( arg = arg )   ! (out)
!>   call DCArgsDebug( arg = arg )  ! (inout)
!>   call DCArgsHelp( arg = arg )   ! (inout)
!>   call DCArgsStrict( arg = arg ) ! (inout)
!>   call DCArgsGet( arg = arg, argv = argv )
!>   do i = 1, size( argv )
!>     write(*,*) argv(i)
!>   end do
!>   deallocate( argv )
!>   call DCArgsClose( arg = arg )  ! (inout)
!> end program dc_args_sample1
!> @endcode
!>
!> 引数にオプションを指定したい場合には, DCArgsOption サブルーチンを
!> 利用してください. オプションの書式に関しては DCArgsOption の
!> 「オプションの書式」を参照してください.
!>
!> @code{.f90}
!> program dc_args_sample2
!>   use dc_types
!>   use dc_string, only: StoA
!>   use dc_args
!>   implicit none
!>   type(ARGS) :: arg
!>   logical :: OPT_size
!>   logical :: OPT_namelist
!>   character(STRING) :: VAL_namelist
!>
!>   call DCArgsOpen( arg = arg )
!>   call DCArgsOption( arg = arg, options = StoA('-s', '--size'), &
!>     & flag = OPT_size, help = "Return number of arguments")
!>   call DCArgsOption( arg = arg, options = StoA('-N', '--namelist'), &
!>     & flag = OPT_namelist, value = VAL_namelist, help = "Namelist filename")
!>
!>   call DCArgsDebug( arg = arg )
!>   call DCArgsHelp( arg = arg )
!>   call DCArgsStrict( arg = arg )
!>
!>   if (OPT_size) then
!>     write(*,*) 'number of arguments :: ', DCArgsNumber(arg)
!>   end if
!>   if (OPT_namelist) then
!>     write(*,*) '--namelist=', trim(VAL_namelist)
!>   else
!>     write(*,*) '--namelist is not found'
!>   end if
!>   call DCArgsClose( arg = arg )
!> end program dc_args_sample2
!> @endcode
!>
!> コマンドライン引数に '-h', '-H', '--help' のいづれかのオプションを
!> 指定することで, オプションの一覧が標準出力に表示されます.
!>
!> ヘルプメッセージの内容を充実させたい場合には DCArgsHelpMsg を
!> 参照してください.
!>
!> @note 後方互換
!>
!> バージョン 20071009 以前に利用可能だった以下の手続きは,
!> 後方互換のため, しばらくは利用可能です.
!>
!> - Open, Close, Option, PutLine, Debug, Help, HelpMsg, Strict, Get, Number
!>
!> @endja
!>
!> @note dc_args モジュールを作成した理由について
!>
!> Fortran コンパイラのほとんどには IARGC, GETARG といった
!> コマンドライン引数取得のための副プログラムが用意されている.
!> これらの副プログラムの利用によって, コマンドラインの引数を
!> 単に取得することは簡単である.
!>
!> しかしこの IARGC, GETARG の使用に際し, 2 つほど面倒な点がある.
!>
!> 1 つはコンパイラ依存による IARGC, GETARG の仕様の違いである.
!> これらの副プログラムは Fortran 規格に含まれないサービスルーチン
!> であるため, たいていのコンパイラにはこの副プログラムは
!> 存在するものの, 仕様が微妙に異なる場合がある. (大抵のコンパイラは
!> GETARG の第一引数を 1 にすると一つ目の引数を取得するが,
!> 古い HITACHI のコンパイラは第一引数を 2 にしないと一つ目の
!> 引数を取得できない, など). そこで gtool5 ライブラリでは
!> これらのコンパイラ依存性を吸収する設計を行っている.
!> dc_args モジュールを使用する際には, これらのコンパイラ依存は
!> 気にしなくてよい. (なお, コンパイラ依存性を実際に
!> 吸収しているのは sysdep モジュールである).
!>
!> 2 つ目は, コマンドライン引数におけるオプション引数
!> (-h や --version など) の取り扱いの不便さである.
!> IARGC や GETARG は単に引数を取得するための副プログラムであり,
!> Perl や Ruby などのインタプリタ言語のように,
!> コマンドライン引数にオプション引数を処理するための
!> ライブラリ (Getopt や OptionParser など) が用意されていない.
!> dc_args モジュールは, Fortran プログラムでもオプション引数を
!> 手軽に扱えるよう, オプション引数処理の
!> ためのコーディングをできるだけ簡素にするべく整備したプログラムである.
!>
!> 設計思想は, Ruby の OptionParser を真似ており,
!> OptionParser クラスのオブジェクトを構造型 ARGS に,
!> new (initialize) メソッドを DCArgsOpen サブルーチンに,
!> on メソッドを DCArgsOption サブルーチンに, parse メソッドを DCArgsGet
!> サブルーチンに見立てている. 言語仕様の違いにより実装や仕様は
!> それなりに異なるが, 構造型 ARGS の変数をオブジェクトに見立て,
!> この変数に対してサブルーチンを作用させることによって
!> オブジェクトへの操作やオブジェクトからの引数情報の取得を行うという点では
!> OptionParser と同様である.
!>
!> おまけ的機能であるが, dc_trace モジュールとの連携も図られており,
!> Debug サブルーチンを使用することにより (使用法は上記参照), 再コン
!> パイルすることなく, プログラムの実行の際に "-D" オプションをつける
!> ことでデバッグメッセージを表示するモードに変更することもできる.
!>
 
module dc_args
  use dc_types, only : string
  use dc_hash, only: hash
  implicit none
  private
 
  public:: args
  public:: dcargsopen, dcargsclose, dcargsoption
  public:: dcargsputline, dcargsdebug, dcargshelp
  public:: dcargshelpmsg, dcargsstrict, dcargsget
  public:: dcargsnumber
 
  !-----------------------------------------------
  ! 後方互換用
  ! For backward compatibility
  public:: Open, Close, option, putline, debug, help, helpmsg, strict, get
  public:: number
 
  !> @en
  !> @brief Derived type for command line argument parsing
  !> @details
  !> Use DCArgsOpen for initialization and DCArgsClose for finalization.
  !> Stores arguments given in command line and information given by
  !> DCArgsOption and DCArgsHelpMsg subroutines within the program.
  !>
  !> See dc_args Usage for detailed usage.
  !> @enden
  !>
  !> @ja
  !> @brief コマンドライン引数解析用の構造型
  !> @details
  !> 初期化には DCArgsOpen を, 終了処理には DCArgsClose を用います.
  !> コマンドライン引数に与えられる引数や, プログラム内で
  !> DCArgsOption, DCArgsHelpMsg サブルーチンによって与えられた情報を
  !> 格納します.
  !>
  !> 詳しい使い方は dc_args の Usage を参照ください.
  !> @endja
  type args
    private
    type(OPT_ENTRY), pointer :: opt_table(:) => null()
                              !< @en List of options specified by DCArgsOption subroutine @enden
                              !< @ja DCArgsOption サブルーチンで指定されるオプションのリスト @endja
    logical :: initialized = .false.
                              !< @en Initialization flag @enden
                              !< @ja 初期化フラグ @endja
    type(cmd_opts_internal), pointer :: cmd_opts_list(:) => null()
                              !< @en List of items identified as options among command line arguments @enden
                              !< @ja コマンドライン引数のうち, オプションとして識別されるもののリスト @endja
    type(hash) :: helpmsg
                              !< @en Help message hash @enden
                              !< @ja ヘルプメッセージハッシュ @endja
  end type args
 
  !> @en
  !> @brief Internal type for option entry
  !> @enden
  !> @ja
  !> @brief オプションエントリ用内部型
  !> @endja
  type opt_entry
    character(STRING), pointer:: options(:) => null()
                              !< @en List of option names @enden
                              !< @ja オプション名リスト @endja
    character(STRING) :: help_message
                              !< @en Help message @enden
                              !< @ja ヘルプメッセージ @endja
    logical :: optvalue_flag
                              !< @en Flag for presence of option value @enden
                              !< @ja オプションの値の有無 @endja
  end type opt_entry
 
  !> @en
  !> @brief Internal type for command line options
  !> @enden
  !> @ja
  !> @brief コマンドラインオプション用内部型
  !> @endja
  type cmd_opts_internal
    character(STRING) :: name
                              !< @en Option name @enden
                              !< @ja オプション名 @endja
    character(STRING) :: value
                              !< @en Option value @enden
                              !< @ja 値 @endja
    logical:: flag_called = .false.
                              !< @en Flag to determine if this option name was called by DCArgsOption @enden
                              !< @ja このオプション名が DCArgsOption で呼ばれたものかどうかを判別するフラグ @endja
  end type cmd_opts_internal
 
  interface dcargsopen
    module procedure dcargsopen0
  end interface
 
  interface dcargsclose
    module procedure dcargsclose0
  end interface
 
  interface dcargsoption
    module procedure dcargsoption0
  end interface
 
  interface dcargsputline
    module procedure dcargsputline0
  end interface
 
  interface dcargsdebug
    module procedure dcargsdebug0
  end interface
 
  interface dcargshelp
    module procedure dcargshelp0
  end interface
 
  interface dcargshelpmsg
    module procedure dcargshelpmsg0
  end interface
 
  interface dcargsstrict
    module procedure dcargsstrict0
  end interface
 
  interface dcargsget
    module procedure dcargsget0
  end interface
 
  interface dcargsnumber
    module procedure dcargsnumber0
  end interface
 
  !-----------------------------------------------
  ! 後方互換用
  ! For backward compatibility
  interface open
    module procedure dcargsopen0
  end interface
 
  interface close
    module procedure dcargsclose0
  end interface
 
  interface option
    module procedure dcargsoption0
  end interface
 
  interface putline
    module procedure dcargsputline0
  end interface
 
  interface debug
    module procedure dcargsdebug0
  end interface
 
  interface help
    module procedure dcargshelp0
  end interface
 
  interface helpmsg
    module procedure dcargshelpmsg0
  end interface
 
  interface strict
    module procedure dcargsstrict0
  end interface
 
  interface get
    module procedure dcargsget0
  end interface
 
  interface number
    module procedure dcargsnumber0
  end interface
 
 
  !-------------------------------------
  !> @en Variables set by BuildArgTable @enden
  !> @ja BuildArgTable で設定される変数 @endja
 
  character(STRING), allocatable, save:: argstr_table(:)
                              !< @en Contents of all arguments (no distinction whether option or not).
                              !<     Set by BuildArgTable. @enden
                              !< @ja 全引数の内容 (オプションかどうかなどの判別は行っていない).
                              !<     BuildArgTable で設定される. @endja
 
  integer, save:: argind_count = -1
                              !< @en Number of all arguments. Set by BuildArgTable. @enden
                              !< @ja 全引数の数. BuildArgTable で設定される. @endja
 
  !-------------------------------------
  !> @en Variables set by SortArgTable @enden
  !> @ja SortArgTable で設定される変数 @endja
 
  type(CMD_OPTS_INTERNAL), allocatable, save :: cmd_opts_list(:)
                              !< @en List of items identified as options among command line arguments.
                              !<     Set by SortArgTable. @enden
                              !< @ja コマンドライン引数のうち, オプションとして識別されるもののリスト.
                              !<     SortArgTable で設定される. @endja
 
  character(STRING), allocatable, save:: cmd_argv_list(:)
                              !< @en List of non-option arguments among command line arguments.
                              !<     Set by SortArgTable. @enden
                              !< @ja コマンドライン引数のうち, オプションではない引数のリスト.
                              !<     SortArgTable で設定される. @endja
 
contains
 
  !> @en
  !> @brief Initialize ARGS derived type variable
  !> @details
  !> Initializes ARGS derived type variable.
  !>
  !> When using ARGS derived type variable, please perform initialization
  !> first with this subroutine.
  !>
  !> This subroutine stores command line argument information obtained
  !> using IARGC and GETARG in lower-level subroutines into argument `arg`.
  !>
  !> @param[out] arg ARGS derived type variable to initialize
  !> @enden
  !>
  !> @ja
  !> @brief 構造型 ARGS 変数の初期化
  !> @details
  !> ARGS 型の変数を初期設定します.
  !>
  !> ARGS 型の変数を利用する際にはまずこのサブルーチンによって
  !> 初期設定を行ってください.
  !>
  !> このサブルーチンは, より下層のサブルーチン内で IARGC や GETARG
  !> を用いて得られたコマンドライン引数の情報を引数 `arg`
  !> へと格納します.
  !>
  !> @param[out] arg 初期化する ARGS 型変数
  !> @endja
  subroutine dcargsopen0(arg)
    use dc_message, only: messagenotify
    implicit none
    type(args), intent(out) :: arg
    integer:: cmd_opts_max
    character(len = *), parameter :: subname = 'DCArgsOpen'
  continue
    if (arg % initialized) then
      call messagenotify('W', subname, 'This argument (type ARGS) is already opend.')
      return
    end if
    call buildargtable
    call sortargtable
    cmd_opts_max = size(cmd_opts_list)
    allocate(arg % cmd_opts_list(cmd_opts_max))
    arg % cmd_opts_list = cmd_opts_list
    nullify( arg % opt_table )
    arg % initialized = .true.
  end subroutine dcargsopen0
 
  !> @en
  !> @brief Finalize ARGS derived type variable
  !> @details
  !> Performs finalization of ARGS derived type variable.
  !>
  !> @param[in,out] arg ARGS derived type variable to finalize
  !> @enden
  !>
  !> @ja
  !> @brief 構造型 ARGS 変数の終了処理
  !> @details
  !> ARGS 型の変数の終了処理を行います.
  !>
  !> @param[in,out] arg 終了処理する ARGS 型変数
  !> @endja
  subroutine dcargsclose0(arg)
    use dc_hash, only: dchashdelete
    implicit none
    type(args), intent(inout) :: arg
    integer :: i
  continue
    if (arg % initialized) then
      if ( associated( arg % opt_table ) ) then
        do i = 1, size(arg % opt_table)
          deallocate(arg % opt_table(i) % options)
        end do
 
        deallocate(arg % opt_table)
      end if
 
      deallocate(arg % cmd_opts_list)
      deallocate(argstr_table)
      deallocate(cmd_argv_list)
      deallocate(cmd_opts_list)
 
      call dchashdelete(arg % helpmsg)
    end if
  end subroutine dcargsclose0
 
  !> @en
  !> @brief Configure for getting command line option
  !> @details
  !> Registers and retrieves option information.
  !>
  !> Among command line arguments, retrieves information about options
  !> given in `options` to `flag` and `value`. If `options` is given
  !> in command line arguments, `.true.` is returned to `flag`, otherwise
  !> `.false.` is returned. If the option has a value specified,
  !> that value is returned to `value`. If the option itself is not given,
  !> an empty string is returned to `value`.
  !>
  !> `help` registers a help message about `options` in `arg`.
  !> This message is output when using subroutine DCArgsHelp.
  !> The message changes depending on whether `value` is given.
  !>
  !> @section option_format Option Format
  !>
  !> Among command line arguments, the following are judged as options:
  !>
  !> - When the first character is '-'. In this case it becomes a short option,
  !>   and only one character after '-' is valid as the option.
  !>
  !> - When the first two characters are '--' (two hyphens).
  !>   In this case it becomes a long option,
  !>   and the string after '--' is valid as the option.
  !>
  !> The option value is the string after "=".
  !>
  !> @param[in,out] arg ARGS derived type variable
  !> @param[in] options Array of option names (e.g., '-s', '--size')
  !> @param[out] flag Returns .true. if option is found
  !> @param[out] value Returns option value if specified (optional)
  !> @param[in] help Help message for this option (optional)
  !> @enden
  !>
  !> @ja
  !> @brief コマンドライン引数オプションを取得するための設定
  !> @details
  !> オプション情報の登録と取得を行います.
  !>
  !> コマンドライン引数のうち, `options` に与えるオプションに関する情
  !> 報を `flag` と `value` に取得します. `options` がコマンドライン
  !> 引数に与えられていれば `flag` に `.true.` が, そうでない場合は
  !> `.false.` が返ります. オプションに値が指定される場合は `value` に
  !> その値が返ります. オプション自体が与えられていない場合には
  !> `value` には空文字が返ります.
  !>
  !> `help` には `options` に関するヘルプメッセージを `arg` に
  !> 登録します. サブルーチン DCArgsHelp を
  !> 用いた際に, このメッセージが出力されます.
  !> `value` を与えているかどうでこのメッセージは変化します.
  !>
  !> @section option_format_ja オプションの書式
  !>
  !> コマンドライン引数のうち, オプションと判定されるのは以下の場合です.
  !>
  !> - 1 文字目が '-' の場合. この場合は短いオプションとなり, '-'
  !>   の次の一文字のみがオプションとして有効になります.
  !>
  !> - 1-2文字目が '--' (ハイフン 2 文字) の場合.
  !>   この場合は長いオプションとなり,
  !>   '--' 以降の文字列がオプションとして有効になります.
  !>
  !> オプションの値は, "=" よりも後ろの文字列になります.
  !>
  !> @param[in,out] arg ARGS 型変数
  !> @param[in] options オプション名の配列 (例: '-s', '--size')
  !> @param[out] flag オプションが見つかった場合に .true. を返す
  !> @param[out] value オプション値が指定されている場合にその値を返す (省略可能)
  !> @param[in] help このオプションのヘルプメッセージ (省略可能)
  !> @endja
  subroutine dcargsoption0(arg, options, flag, value, help)
    use dc_message, only: messagenotify
    implicit none
    type(args), intent(inout) :: arg
    character(len = *), intent(in) :: options(:)
    logical, intent(out) :: flag
    character(len = *), intent(out), optional :: value
    character(len = *), intent(in), optional :: help
    integer :: i, j, options_size, table_size
    type(opt_entry), allocatable :: local_tables(:)
    character(len = STRING) :: opt_name, opt_value, opt_full
    character(len = *), parameter  :: subname = 'DCArgsOption'
  continue
    flag = .false.
    if (present(value)) value = ''
    if (.not. arg % initialized) then
      call messagenotify('W', subname, 'Call Open before Option in dc_args.')
      call dcargsopen(arg)
    end if
    options_size = size(options)
    if (options_size < 1) then
      return
    end if
 
    !-----------------------------------
    ! 構造体 ARGS へのヘルプメッセージ用の情報登録
    ! * まずはテーブル arg % opt_table を一つ広げる.
    !-----------------------------------
    if ( .not. associated( arg % opt_table ) ) then
      ! 1 つめのオプション指定
      !
      table_size = 0
      allocate(arg % opt_table(table_size + 1))
    else
      ! 2 つめ以降のオプション指定
      !
      table_size = size(arg % opt_table)
      allocate(local_tables(table_size))
      local_tables(1:table_size) = arg % opt_table(1:table_size)
      deallocate(arg % opt_table)
      allocate(arg % opt_table(table_size + 1))
      arg % opt_table(1:table_size) = local_tables(1:table_size)
      deallocate(local_tables)
    end if
 
    !----- 値の代入 -----
    allocate(arg % opt_table(table_size + 1) % options(options_size))
    arg % opt_table(table_size + 1) % options = options
    arg % opt_table(table_size + 1) % help_message = ''
    if (present(help)) then
      arg % opt_table(table_size + 1) % help_message = help
    end if
    arg % opt_table(table_size + 1) % optvalue_flag = present(value)
 
 
    !----- options の正規化 -----
    do i = 1, options_size
      opt_full = arg % opt_table(table_size + 1) % options(i)
      if (dcoptionformc(opt_full, opt_name, opt_value)) then
        arg % opt_table(table_size + 1) % options(i) = opt_name
      else
        if (len(trim(adjustl(opt_full))) < 2) then
          arg % opt_table(table_size + 1) % options(i) = &
            & '-' // trim(adjustl(opt_full))
        else
          arg % opt_table(table_size + 1) % options(i) = &
            & '--' // trim(adjustl(opt_full))
        end if
      end if
    end do
 
    ! arg % cmd_opts_list 内の探査と flag, value への代入
    ! 呼ばれたものに関しては arg % cmd_opts_list % flag_called を
    ! .true. に
    do i = 1, options_size
      do j = 1, size(arg % cmd_opts_list)
        if (trim(arg % opt_table(table_size + 1) % options(i)) &
          &             == trim(arg % cmd_opts_list(j) % name)) then
          flag = .true.
          if (present(value)) then
            value = arg % cmd_opts_list(j) % value
          end if
          arg % cmd_opts_list(j) % flag_called = .true.
        end if
      end do
    end do
  end subroutine dcargsoption0
 
  !> @en
  !> @brief Auto-configure debug option
  !> @details
  !> Performs automatic configuration of the debug option.
  !>
  !> When -D or --debug is specified, automatically calls
  !> dc_trace#SetDebug to configure `arg`.
  !>
  !> @param[in,out] arg ARGS derived type variable
  !> @enden
  !>
  !> @ja
  !> @brief デバッグオプションの自動設定
  !> @details
  !> デバッグオプションの自動設定を行います.
  !>
  !> -D もしくは --debug が指定された際, 自動的に
  !> dc_trace#SetDebug を呼び出すよう `arg` を設定します.
  !>
  !> @param[in,out] arg ARGS 型変数
  !> @endja
  subroutine dcargsdebug0(arg)
    use dc_types, only: string
    use dc_string, only: stoa, stoi
    use dc_trace, only: setdebug
    use dc_message, only: messagenotify
    implicit none
    type(args), intent(inout) :: arg
    logical :: OPT_debug
    character(STRING) :: VAL_debug
    character(len = *), parameter  :: subname = 'DCArgsDebug'
  continue
    if (.not. arg % initialized) then
      call messagenotify('W', subname, 'Call Open before Debug in dc_args.')
      call dcargsopen(arg)
    end if
    call option(arg, stoa('-D', '--debug'), opt_debug, val_debug, &
      & help="call dc_trace#SetDebug (display a lot of messages for debug). " // &
      & "VAL is unit number (default is standard output)")
    if (opt_debug) then
      if (trim(val_debug) == '') then
        call setdebug
      else
        call setdebug(stoi(val_debug))
      end if
    end if
    return
  end subroutine dcargsdebug0
 
 
  !> @en
  !> @brief Auto-configure help option
  !> @details
  !> Performs automatic configuration of the help option.
  !>
  !> When any of -h, -H, --help is specified, automatically displays
  !> information configured in `arg` as a help message and then
  !> terminates the program.
  !> As a rule, please call DCArgsOption and DCArgsDebug subroutines
  !> before this subroutine.
  !>
  !> If `.true.` is specified for `force`, the help message is displayed
  !> and the program is terminated even if -H, --help option is not given.
  !>
  !> Information displayed in the help message can be added using
  !> DCArgsOption and DCArgsHelpMsg subroutines.
  !>
  !> @param[in,out] arg ARGS derived type variable
  !> @param[in] force If .true., display help even without option (optional)
  !> @enden
  !>
  !> @ja
  !> @brief ヘルプオプションの自動設定
  !> @details
  !> ヘルプオプションの自動設定を行います.
  !>
  !> -h, -H, --help のいづれかが指定された際, 自動的に `arg` 内に設定された
  !> 情報をヘルプメッセージとして表示した後, プログラムを終了させます.
  !> 原則的に, このサブルーチンよりも前に DCArgsOption, DCArgsDebug
  !> のサブルーチンを呼んで下さい.
  !>
  !> `force` に `.true.` が指定される場合, -H, --help オプションが与え
  !> られない場合でもヘルプメッセージを表示した後, プログラムを終了さ
  !> せます.
  !>
  !> ヘルプメッセージに表示される情報は, DCArgsOption, DCArgsHelpMsg
  !> サブルーチンによって付加することが可能です.
  !>
  !> @param[in,out] arg ARGS 型変数
  !> @param[in] force .true. の場合, オプション無しでもヘルプを表示 (省略可能)
  !> @endja
  subroutine dcargshelp0(arg, force)
    use dc_types, only: string, stdout
    use dc_string, only: stoa, stoi, printf, concat, joinchar, uchar, lchar
    use dc_present, only: present_and_true
    use dc_message, only: messagenotify
    use dc_hash, only: dchashget, dchashdelete, dchashrewind, dchashnext
    implicit none
    type(args), intent(inout) :: arg
    logical, intent(in), optional :: force
    logical :: OPT_help, found, end
    character(STRING) :: VAL_help, options_msg, help_msg, category
    character(STRING), pointer :: localopts(:) => null()
    integer :: unit, i
    character(len = *), parameter  :: subname = 'DCArgsHelp'
  continue
    if (.not. arg % initialized) then
      call messagenotify('W', subname, 'Call Open before Help in dc_args.')
      call dcargsopen(arg)
    end if
    call dcargsoption(arg, stoa('-h', '-H', '--help'), opt_help, val_help, &
      & help="display this help and exit. " // &
      & "VAL is unit number (default is standard output)")
    if (.not. opt_help .and. .not. present_and_true(force)) then
      return
    end if
    if (trim(val_help) == '') then
      unit = stdout
    else
      unit = stoi(val_help)
    end if
 
    call printf(unit, '')
 
    call dchashget(arg % helpmsg, 'TITLE', help_msg, found)
    if (found) then
      call printf(unit, '%c', c1=trim(help_msg))
      call printf(unit, '')
      call dchashdelete(arg % helpmsg, 'TITLE')
    end if
 
    call dchashget(arg % helpmsg, 'OVERVIEW', help_msg, found)
    if (found) then
      call printf(unit, 'Overview::')
      call printautolinefeed(unit, help_msg, indent='     ')
      call printf(unit, '')
      call dchashdelete(arg % helpmsg, 'OVERVIEW')
    end if
 
    call dchashget(arg % helpmsg, 'USAGE', help_msg, found)
    if (found) then
      call printf(unit, 'Usage::')
      call printautolinefeed(unit, help_msg, indent='     ')
      call printf(unit, '')
      call dchashdelete(arg % helpmsg, 'USAGE')
    end if
 
    call printf(unit, 'Options::')
    if ( associated(arg % opt_table) ) then
      do i = 1, size(arg % opt_table)
        options_msg = ' '
        if (arg % opt_table(i) % optvalue_flag) then
          call concat(arg % opt_table(i) % options, '=VAL', localopts)
        else
          allocate(localopts(size(arg % opt_table(i) % options)))
          localopts = arg % opt_table(i) % options
        end if
        options_msg = trim(options_msg) // trim(joinchar(localopts))
        deallocate(localopts)
        call printf(unit, ' %c', c1=trim(options_msg))
        call printautolinefeed(unit, &
          & arg % opt_table(i) % help_message, indent='     ')
        call printf(unit, '')
      end do
    end if
 
    call dchashrewind(arg % helpmsg)
    do
      call dchashnext(arg % helpmsg, category, help_msg, end)
      if (end) exit
 
      call printf(unit, '%c%c::', &
        & c1=trim(uchar(category(1:1))), c2=trim(lchar(category(2:))))
      call printautolinefeed(unit, help_msg, indent='     ')
      call printf(unit, '')
 
    enddo
 
    call dcargsclose(arg)
 
    stop
  end subroutine dcargshelp0
 
  !> @en
  !> @brief Add help message
  !> @details
  !> Adds a message to be displayed when using subroutine DCArgsHelp.
  !> Messages with `category` set to "Title", "Overview", or "Usage"
  !> are displayed above "Options", while others are displayed below.
  !> Give the message to `msg`.
  !>
  !> @section helpmsg_example Example
  !>
  !> @code{.f90}
  !> program dc_args_sample3
  !>   use dc_types
  !>   use dc_string, only: StoA
  !>   use dc_args
  !>   implicit none
  !>   type(ARGS) :: arg
  !>   logical :: OPT_namelist
  !>   character(STRING) :: VAL_namelist
  !>   character(STRING), pointer :: argv(:) => null()
  !>   integer :: i
  !>
  !>   call DCArgsOpen( arg = arg )
  !>   call DCArgsHelpMsg( arg = arg, category = 'Title', &
  !>     & msg = 'dcargs :: Test program of dc_args' )
  !>   call DCArgsHelpMsg( arg = arg, category = 'Usage', &
  !>     & msg = 'dcargs [Options] arg1, arg2, ...')
  !>   call DCArgsOption( arg = arg, options = StoA('-N', '--namelist'), &
  !>     & flag = OPT_namelist, value = VAL_namelist, help = "Namelist filename")
  !>   call DCArgsHelpMsg( arg = arg, category = 'DESCRIPTION', &
  !>     & msg = '(1) Define type "HASH". (2) Open the variable. ...')
  !>   call DCArgsHelpMsg( arg = arg, category = 'Copyright', &
  !>     & msg = 'Copyright (C) GFD Dennou Club, 2008. All rights reserved.')
  !>   call DCArgsDebug( arg = arg )
  !>   call DCArgsHelp( arg = arg )
  !>   call DCArgsStrict( arg = arg )
  !>   call DCArgsGet( arg = arg, argv = argv )
  !>   write(*,*) '--namelist=', trim( VAL_namelist )
  !>   do i = 1, size(argv)
  !>     write(*,*) argv(i)
  !>   end do
  !>   deallocate( argv )
  !>   call DCArgsClose( arg = arg )
  !> end program dc_args_sample3
  !> @endcode
  !>
  !> By specifying any of '-h', '-H', '--help' options in command line
  !> arguments, the message given by HelpMsg and the list of options
  !> are displayed to standard output.
  !>
  !> @param[in,out] arg ARGS derived type variable
  !> @param[in] category Category name ("Title", "Overview", "Usage", etc.)
  !> @param[in] msg Help message to add
  !> @enden
  !>
  !> @ja
  !> @brief ヘルプメッセージを追加
  !> @details
  !> サブルーチン DCArgsHelp を使用した際に出力されるメッセージを
  !> 付加します. `category` に "Title", "Overview", "Usage" が
  !> 指定されたものは "Options" よりも上部に,
  !> それ以外のものは下部に表示されます.
  !> `msg` にはメッセージを与えてください.
  !>
  !> @section helpmsg_example_ja 例
  !>
  !> @code{.f90}
  !> program dc_args_sample3
  !>   use dc_types
  !>   use dc_string, only: StoA
  !>   use dc_args
  !>   implicit none
  !>   type(ARGS) :: arg
  !>   logical :: OPT_namelist
  !>   character(STRING) :: VAL_namelist
  !>   character(STRING), pointer :: argv(:) => null()
  !>   integer :: i
  !>
  !>   call DCArgsOpen( arg = arg )
  !>   call DCArgsHelpMsg( arg = arg, category = 'Title', &
  !>     & msg = 'dcargs :: Test program of dc_args' )
  !>   call DCArgsHelpMsg( arg = arg, category = 'Usage', &
  !>     & msg = 'dcargs [Options] arg1, arg2, ...')
  !>   call DCArgsOption( arg = arg, options = StoA('-N', '--namelist'), &
  !>     & flag = OPT_namelist, value = VAL_namelist, help = "Namelist filename")
  !>   call DCArgsHelpMsg( arg = arg, category = 'DESCRIPTION', &
  !>     & msg = '(1) Define type "HASH". (2) Open the variable. ...')
  !>   call DCArgsHelpMsg( arg = arg, category = 'Copyright', &
  !>     & msg = 'Copyright (C) GFD Dennou Club, 2008. All rights reserved.')
  !>   call DCArgsDebug( arg = arg )
  !>   call DCArgsHelp( arg = arg )
  !>   call DCArgsStrict( arg = arg )
  !>   call DCArgsGet( arg = arg, argv = argv )
  !>   write(*,*) '--namelist=', trim( VAL_namelist )
  !>   do i = 1, size(argv)
  !>     write(*,*) argv(i)
  !>   end do
  !>   deallocate( argv )
  !>   call DCArgsClose( arg = arg )
  !> end program dc_args_sample3
  !> @endcode
  !>
  !> コマンドライン引数に '-h', '-H', '--help' のいづれかのオプション
  !> を指定することで, HelpMsg で与えたメッセージと, オプションの一覧
  !> が標準出力に表示されます.
  !>
  !> @param[in,out] arg ARGS 型変数
  !> @param[in] category カテゴリ名 ("Title", "Overview", "Usage" など)
  !> @param[in] msg 追加するヘルプメッセージ
  !> @endja
  subroutine dcargshelpmsg0(arg, category, msg)
    use dc_hash, only: dchashput
    use dc_string, only: uchar
    use dc_message, only: messagenotify
    implicit none
    type(args), intent(inout) :: arg
    character(*), intent(in) :: category
    character(*), intent(in) :: msg
    character(len = *), parameter  :: subname = 'DCArgsHelpMsg'
  continue
    if (.not. arg % initialized) then
      call messagenotify('W', subname, 'Call Open before Help in dc_args.')
      call dcargsopen(arg)
    end if
    call dchashput(arg % helpmsg, key=uchar(category), value=msg)
  end subroutine dcargshelpmsg0
  
 
  !> @en
  !> @brief Perform option check
  !> @details
  !> Performs option validation.
  !>
  !> Among command line argument options, if any option that is not
  !> configured by DCArgsOption subroutine exists, a warning is returned.
  !> If `.true.` is specified for `severe`, an error is returned and
  !> the program terminates.
  !> Before calling this subroutine, please call DCArgsOption, DCArgsDebug,
  !> and DCArgsHelp subroutines.
  !>
  !> By applying this subroutine to an ARGS derived type variable,
  !> you can check whether the options given as command line arguments
  !> are correctly recognized by the program.
  !>
  !> @param[in,out] arg ARGS derived type variable
  !> @param[in] severe If .true., return error and terminate (optional)
  !> @enden
  !>
  !> @ja
  !> @brief オプションチェックを行う
  !> @details
  !> オプションチェックを行います.
  !>
  !> コマンドライン引数のオプションとして指定されたものの内,
  !> DCArgsOption サブルーチンで設定されていないものが存在する
  !> 場合には警告を返します. `severe` に `.true.` を指定すると
  !> エラーを返して終了します.
  !> このサブルーチンを呼ぶ前に, DCArgsOption, DCArgsDebug,
  !> DCArgsHelp サブルーチンを呼んでください.
  !>
  !> 構造型 ARGS の変数に対してこのサブルーチンを適用しておく
  !> ことで, コマンドライン引数として与えたオプションが正しく
  !> プログラムが認識しているかどうかをチェックすることができます.
  !>
  !> @param[in,out] arg ARGS 型変数
  !> @param[in] severe .true. の場合, エラーを返して終了 (省略可能)
  !> @endja
  subroutine dcargsstrict0(arg, severe)
    use dc_types, only: string
    use dc_present, only: present_and_true
    use dc_message, only: messagenotify
    implicit none
    type(args), intent(inout) :: arg
    logical, intent(in), optional :: severe
    character(STRING) :: err_mess
    integer :: i
    character(len = *), parameter  :: subname = 'DCArgsStrict'
  continue
    if (.not. arg % initialized) then
      call messagenotify('W', subname, 'Call Open before Help in dc_args.')
      call dcargsopen(arg)
    end if
    do i = 1, size(arg % cmd_opts_list)
      err_mess = trim(arg % cmd_opts_list(i) % name) // ' is invalid option.'
      if (.not. arg % cmd_opts_list(i) % flag_called) then
        if (present_and_true(severe)) then
          call messagenotify('E', subname, err_mess)
        else
          call messagenotify('W', subname, err_mess)
        end if
      end if
    end do
  end subroutine dcargsstrict0
 
 
  !> @en
  !> @brief Get non-option command line arguments
  !> @details
  !> Returns command line arguments that are not options to `argv`.
  !>
  !> `argv` is a pointer to a character array.
  !> When giving it as an argument, be sure to give it in an empty state.
  !>
  !> @param[in,out] arg ARGS derived type variable
  !> @param[out] argv Pointer to character array to receive non-option arguments
  !> @enden
  !>
  !> @ja
  !> @brief オプションでないコマンドライン引数を取得
  !> @details
  !> コマンドライン引数のうち, オプションではないものを
  !> `argv` に返します.
  !>
  !> `argv` は文字型配列のポインタです.
  !> 引数として与える場合には必ず空状態にして与えてください.
  !>
  !> @param[in,out] arg ARGS 型変数
  !> @param[out] argv オプションでない引数を受け取る文字型配列のポインタ
  !> @endja
  subroutine dcargsget0(arg, argv)
    use dc_string, only: stoa, stoi, printf, concat, joinchar
    use dc_present, only: present_and_true
    use dc_message, only: messagenotify
    implicit none
    type(args), intent(inout) :: arg
    character(*), pointer :: argv(:) !(out)
    integer :: i, cmd_argv_max
    character(len = *), parameter  :: subname = 'DCArgsGet'
  continue
    if (.not. arg % initialized) then
      call messagenotify('W', subname, 'Call Open before Help in dc_args.')
      call dcargsopen(arg)
    end if
    cmd_argv_max = size(cmd_argv_list)
    allocate(argv(cmd_argv_max))
    do i = 1, cmd_argv_max
      argv(i) = cmd_argv_list(i)
    end do
  end subroutine dcargsget0
 
  !> @en
  !> @brief Return number of command line arguments
  !> @details
  !> Returns the number of non-option arguments given as command line arguments.
  !>
  !> @param[in,out] arg ARGS derived type variable
  !> @return Number of command line arguments (excluding options)
  !> @enden
  !>
  !> @ja
  !> @brief コマンドライン引数の数を返す
  !> @details
  !> コマンドライン引数として与えられた引数の数を返します.
  !>
  !> @param[in,out] arg ARGS 型変数
  !> @return コマンドライン引数の数 (オプションを除く)
  !> @endja
  function dcargsnumber0(arg) result(result)
    use dc_message, only: messagenotify
    implicit none
    type(args), intent(inout) :: arg
    integer :: result
    character(len = *), parameter  :: subname = 'DCArgsNumber'
  continue
    if (.not. arg % initialized) then
      call messagenotify('W', subname, 'Call Open before Help in dc_args.')
      call dcargsopen(arg)
    end if
    result = size(cmd_argv_list)
  end function dcargsnumber0
 
  !> @en
  !> @brief Print information about ARGS variable
  !> @details
  !> Displays information about `arg` to standard output.
  !> This is mainly for debugging purposes.
  !>
  !> @param[in] arg ARGS derived type variable
  !> @enden
  !>
  !> @ja
  !> @brief ARGS 変数の情報を表示
  !> @details
  !> `arg` に関する情報を標準出力に表示します.
  !> 主にデバッグ用途に使用します.
  !>
  !> @param[in] arg ARGS 型変数
  !> @endja
  subroutine dcargsputline0(arg)
    use dc_types, only: stdout
    use dc_string, only: printf, joinchar
    implicit none
    type(args), intent(in) :: arg
    integer :: i
  continue
    if (.not. arg % initialized) then
      call printf(stdout, '#<ARGS:: @initialized=%y>', l=(/arg % initialized/))
      return
    end if
    call printf(stdout, '#<ARGS:: @initialized=%y,', l=(/arg % initialized/))
    call printf(stdout, '  @opt_table(:)=')
    if ( associated(arg % opt_table) ) then
      do i = 1, size(arg % opt_table)
        call printf(stdout, '    #<OPT_ENTRY:: ')
        call printf(stdout, '      @options=%c, @help_message=%c, @optvalue_flag=%y', &
          & c1=trim(joinchar(arg % opt_table(i) % options)), &
          & c2=trim(arg % opt_table(i) % help_message), &
          & l=(/arg % opt_table(i) % optvalue_flag/))
        call printf(stdout, '    >')
      end do
    end if
    call printf(stdout, '  ,')
    call printf(stdout, '  @cmd_opts_list(:)=')
    do i = 1, size(arg % cmd_opts_list)
      call printf(stdout, '    #<CMD_OPTS_INTERNAL:: ')
      call printf(stdout, '      @name=%c, @value=%c, @flag_called=%y', &
        & c1=trim(arg % cmd_opts_list(i) % name), &
        & c2=trim(arg % cmd_opts_list(i) % value), &
        & l=(/arg % cmd_opts_list(i) % flag_called/))
      call printf(stdout, '    >')
    end do
    call printf(stdout, '  ,')
    call printf(stdout, '  @cmd_argv_list(:)=%c', &
      & c1=trim(joinchar(cmd_argv_list)))
    call printf(stdout, '>')
 
  end subroutine dcargsputline0
 
  !> @en
  !> @brief Print string with automatic line feed
  !> @details
  !> Outputs a string with automatic line wrapping.
  !> This is a subroutine for internal use within this module.
  !>
  !> The text given to `fmt` is wrapped to within `length` characters
  !> (default is 70 if not specified) and output. When `indent` is
  !> specified, that string is inserted at the beginning of each line.
  !> The default output destination is standard output. You can change
  !> the output destination by setting the unit number to `unit`.
  !>
  !> @param[in] unit Output unit number (optional)
  !> @param[in] fmt Format string to output
  !> @param[in] length Line length (default 70) (optional)
  !> @param[in] indent Indentation string (optional)
  !> @enden
  !>
  !> @ja
  !> @brief 文字列を自動改行して出力
  !> @details
  !> 文字列を自動改行して出力します.
  !> このモジュール内部で用いるためのサブルーチンです.
  !>
  !> `fmt` に与えられた文章を文字数 `length` (指定されない場合 70)
  !> 以内に改行し, 出力します. 出力の際, `indent` が指定されていると
  !> その文字列を行頭に挿入して出力を行います.
  !> 出力先はデフォルトは標準出力となります. `unit` に出力装置番号
  !> を設定することで出力先を変更できます.
  !>
  !> @param[in] unit 出力装置番号 (省略可能)
  !> @param[in] fmt 出力するフォーマット文字列
  !> @param[in] length 行の長さ (デフォルト 70) (省略可能)
  !> @param[in] indent 字下げ文字列 (省略可能)
  !> @endja
  subroutine printautolinefeed(unit, fmt, length, indent)
    use dc_types, only: string, stdout
    use dc_string, only: split
    implicit none
    character(*), intent(in) :: fmt
    integer,      intent(in), optional :: length ! 一行の長さ
    character(*), intent(in), optional :: indent ! 字下げ文字列
    integer,      intent(in), optional :: unit   ! 出力装置
    character(STRING), pointer :: carray_tmp(:) => null()
    character(STRING) :: store_str
    integer, parameter :: default_len = 70
    integer :: i, split_len, indent_len, unit_num
    logical :: new_line_flag
  continue
    if (present(unit)) then
      unit_num = unit
    else
      unit_num = stdout
    end if
 
    if (present(indent)) then
      indent_len = len(indent)
    else
      indent_len = 0
    end if
 
    if (present(length)) then
      split_len = length - indent_len
    else
      split_len = default_len - indent_len
    end if
 
 
    nullify(carray_tmp)
    call split(fmt, carray_tmp, '')
    store_str = ''
    new_line_flag = .true.
    i = 1
    do
      if (i > size(carray_tmp)) then
        write(unit_num, '(A)') trim(store_str)
        exit
      end if
 
      if (len(trim(store_str)) + len(trim(carray_tmp(i))) > split_len) then
        if (new_line_flag) then
          write(unit_num, '(A)') trim(carray_tmp(i))
          i = i + 1
        else
          write(unit_num, '(A)') trim(store_str)
          store_str = ''
          new_line_flag = .true.
        end if
        cycle
      end if
 
      if (new_line_flag .and. present(indent)) then
        store_str = indent // trim(carray_tmp(i))
      else
        store_str = trim(store_str) // ' ' // trim(carray_tmp(i))
      end if
      new_line_flag = .false.
      i = i + 1
    end do
 
  end subroutine printautolinefeed
 
  !> @en
  !> @brief Sort argument table (internal use)
  !> @details
  !> This is an internal subroutine for sorting arguments.
  !>
  !> Uses argind_count and argstr_table set by BuildArgTable to
  !> configure cmd_argv_list and cmd_opts_list.
  !>
  !> If this subroutine has already been called, it returns without doing anything.
  !> @enden
  !>
  !> @ja
  !> @brief 引数テーブルの振り分け (内部使用)
  !> @details
  !> 内部向けの引数振り分けのためのサブルーチンです.
  !>
  !> BuildArgTable で設定された argind_count, argstr_table を
  !> 用い, cmd_argv_list, cmd_opts_list を設定します.
  !>
  !> 既に一度でも呼ばれている場合, 何もせずに終了します.
  !> @endja
  subroutine sortargtable
    use dc_types, only: string
    implicit none
    character(STRING):: raw_arg, name, value
    integer:: i, cmd_argv_count, cmd_opts_count, cmd_argv_max, cmd_opts_max
  continue
    if (allocated(cmd_opts_list)) return
    cmd_argv_count = 0
    cmd_opts_count = 0
    check_count: do, i = 1, argind_count
      raw_arg = argstr_table(i)
      if (dcoptionformc(raw_arg, name, value)) then
        cmd_opts_count = cmd_opts_count + 1
      else
        cmd_argv_count = cmd_argv_count + 1
      end if
    end do check_count
 
    cmd_argv_max = cmd_argv_count
    cmd_opts_max = cmd_opts_count
 
    allocate(cmd_argv_list(cmd_argv_max))
    allocate(cmd_opts_list(cmd_opts_max))
 
    cmd_argv_count = 0
    cmd_opts_count = 0
    arg_get : do, i = 1, argind_count
      raw_arg = argstr_table(i)
      if (dcoptionformc(raw_arg, name, value)) then
        cmd_opts_count = cmd_opts_count + 1
        cmd_opts_list(cmd_opts_count) % name = name
        cmd_opts_list(cmd_opts_count) % value = value
        cmd_opts_list(cmd_opts_count) % flag_called = .false.
      else
        cmd_argv_count = cmd_argv_count + 1
        cmd_argv_list(cmd_argv_count) = raw_arg
      end if
    end do arg_get
  end subroutine sortargtable
 
  !> @en
  !> @brief Build argument table (internal use)
  !> @details
  !> This is an internal subroutine for command line argument processing.
  !>
  !> Calls sysdep#SysdepArgCount and sysdep#SysdepArgGet from the sysdep
  !> module, and stores their contents in argind_count and argstr_table.
  !>
  !> If this subroutine has already been called, it returns without doing anything.
  !> @enden
  !>
  !> @ja
  !> @brief 引数テーブルの構築 (内部使用)
  !> @details
  !> 内部向けコマンドライン引数処理のサブルーチンです.
  !>
  !> モジュール sysdep の sysdep#SysdepArgCount, sysdep#SysdepArgGet
  !> を呼び出し, その内容を argind_count と argstr_table に格納します.
  !>
  !> 既に一度でも呼ばれている場合, 何もせずに終了します.
  !> @endja
  subroutine buildargtable
    use sysdep, only: sysdepargcount, sysdepargget
    use dc_types, only: string
    implicit none
    integer:: i, narg, nargmax
    character(len = STRING):: value
    character(len = STRING), allocatable:: localtab(:)
  continue
    if (argind_count >= 0) return
    nargmax = sysdepargcount()
    allocate(localtab(nargmax))
    narg = 0
    do, i = 1, nargmax
      call sysdepargget(i, value)
      narg = narg + 1
      localtab(narg) = value
    enddo
    argind_count = narg
    allocate(argstr_table(narg))
    argstr_table(1: narg) = localtab(1: narg)
    deallocate(localtab)
  end subroutine buildargtable
 
  !> @en
  !> @brief Check if argument is an option (internal use)
  !> @details
  !> By passing a string obtained as an argument to `argument`,
  !> determines whether it is an option or not. If determined to be
  !> an option, returns `.true.` as the return value, and returns
  !> the option name to `name` and its value to `value`.
  !> If no value is attached to the option, an empty string is returned to `value`.
  !>
  !> If it is not an option, returns `.false.` as the return value,
  !> and returns empty strings to `name` and `value`.
  !>
  !> The following cases are determined as options:
  !>
  !> - If the first character is '-'. In this case it becomes a short option,
  !>   and only one character after '-' is valid as the option.
  !>
  !> - If characters 1-2 are '--'. In this case it becomes a long option,
  !>   and the string after '--' is valid as the option.
  !>
  !> The option value is the string after "=".
  !>
  !> @section optionformc_example Example
  !>
  !> | argument      | name       | value  | result  |
  !> |---------------|------------|--------|---------|
  !> | arg           | (empty)    | (empty)| .false. |
  !> | -O            | -O         | (empty)| .true.  |
  !> | -debug        | -d         | (empty)| .true.  |
  !> | --debug       | --debug    | (empty)| .true.  |
  !> | -I=/usr       | -I         | /usr   | .true.  |
  !> | --include=/usr| --include  | /usr   | .true.  |
  !>
  !> @param[in] argument Argument string to check
  !> @param[out] name Option name (empty if not an option)
  !> @param[out] value Option value (empty if not specified)
  !> @return .true. if argument is an option, .false. otherwise
  !> @enden
  !>
  !> @ja
  !> @brief 引数がオプションかどうか判定 (内部使用)
  !> @details
  !> 引数として得られた文字列を `argument` に渡すことで,
  !> それがオプションなのかそうでないのかを判別し, もしも
  !> オプションと判別した場合には戻り値に `.true.` を返し,
  !> `name` にオプション名, `value` にその値を返す.
  !> オプションに値が付加されない場合は `value` には空白を返す.
  !>
  !> オプションではない場合は戻り値に `.false.` を返し,
  !> `name`, `value` には空白を返す.
  !>
  !> オプションと判定されるのは以下の場合です.
  !>
  !> - 一文字目が '-' の場合. この場合は短いオプションとなり, '-'
  !>   の次の一文字のみがオプションとして有効になります.
  !>
  !> - 1-2文字目が '--' の場合. この場合は長いオプションとなり,
  !>   '--' 以降の文字列がオプションとして有効になります.
  !>
  !> オプションの値は, "=" よりも後ろの文字列になります.
  !>
  !> @section optionformc_example_ja 例
  !>
  !> | argument      | name       | value  | 返り値  |
  !> |---------------|------------|--------|---------|
  !> | arg           | 空白       | 空白   | .false. |
  !> | -O            | -O         | 空白   | .true.  |
  !> | -debug        | -d         | 空白   | .true.  |
  !> | --debug       | --debug    | 空白   | .true.  |
  !> | -I=/usr       | -I         | /usr   | .true.  |
  !> | --include=/usr| --include  | /usr   | .true.  |
  !>
  !> @param[in] argument チェックする引数文字列
  !> @param[out] name オプション名 (オプションでない場合は空白)
  !> @param[out] value オプション値 (指定されていない場合は空白)
  !> @return 引数がオプションの場合 .true., そうでなければ .false.
  !> @endja
  function dcoptionformc(argument, name, value) result(result)
    implicit none
    character(len = *), intent(in):: argument
    character(len = *), intent(out):: name, value
    logical :: result
    integer:: equal
  continue
    equal = index(argument, '=')
    if (argument(1:1) == '-' .and. argument(2:2) /= '-') then
      ! Short Option
      if (equal == 0) then
        name = argument(1:2)
        value = ""
      else
        name = argument(1:2)
        value = argument(equal+1: )
      endif
      result = .true.
    elseif (argument(1:2) == '--') then
      ! Long Option
      if (equal == 0) then
        name = argument
        value = ""
      else
        name = argument(1:equal-1)
        value = argument(equal+1: )
      endif
      result = .true.
!    elseif (equal == 0 .and. &
!      &     verify(argument(1:equal-1), WORDCHARS) == 0) then
!      ! ???
!      name = argument(1:equal-1)
!      value = argument(equal+1: )
!      result = .true.
    else
      ! No Option (normal arguments)
      name = ""
      value = ""
      result = .false.
    endif
  end function dcoptionformc
 
 
 
end module dc_args