ruby--ruby/lib/rdoc/parser/f95.rb

require 'rdoc/parser'

##
# = Fortran95 RDoc Parser
#
# == Overview
#
# This parser parses Fortran95 files with suffixes "f90", "F90", "f95" and
# "F95". Fortran95 files are expected to be conformed to Fortran95 standards.
#
# == Rules
#
# Fundamental rules are same as that of the Ruby parser.  But comment markers
# are '!' not '#'.
#
# === Correspondence between RDoc documentation and Fortran95 programs
#
# F95 parses main programs, modules, subroutines, functions, derived-types,
# public variables, public constants, defined operators and defined
# assignments.  These components are described in items of RDoc documentation,
# as follows.
#
# Files :: Files (same as Ruby)
# Classes:: Modules
# Methods:: Subroutines, functions, variables, constants, derived-types,
#           defined operators, defined assignments
# Required files:: Files in which imported modules, external subroutines and
#                  external functions are defined.
# Included Modules:: List of imported modules
# Attributes:: List of derived-types, List of imported modules all of whose
#              components are published again
#
# Components listed in 'Methods' (subroutines, functions, ...) defined in
# modules are described in the item of 'Classes'.  On the other hand,
# components defined in main programs or as external procedures are described
# in the item of 'Files'.
#
# === Components parsed by default
#
# By default, documentation on public components (subroutines, functions,
# variables, constants, derived-types, defined operators, defined assignments)
# are generated.
#
# With "--all" option, documentation on all components are generated (almost
# same as the Ruby parser).
#
# === Information parsed automatically
#
# The following information is automatically parsed.
#
# * Types of arguments
# * Types of variables and constants
# * Types of variables in the derived types, and initial values
# * NAMELISTs and types of variables in them, and initial values
#
# Aliases by interface statement are described in the item of 'Methods'.
#
# Components which are imported from other modules and published again are
# described in the item of 'Methods'.
#
# === Format of comment blocks
#
# Comment blocks should be written as follows.
#
# Comment blocks are considered to be ended when the line without '!' appears.
#
# The indentation is not necessary.
#
#   ! (Top of file)
#   !
#   ! Comment blocks for the files.
#   !
#   !--
#   ! The comment described in the part enclosed by
#   ! "!--" and "!++" is ignored.
#   !++
#   !
#   module hogehoge
#     !
#     ! Comment blocks for the modules (or the programs).
#     !
#
#     private
#
#     logical            :: a     ! a private variable
#     real, public       :: b     ! a public variable
#     integer, parameter :: c = 0 ! a public constant
#
#     public :: c
#     public :: MULTI_ARRAY
#     public :: hoge, foo
#
#     type MULTI_ARRAY
#       !
#       ! Comment blocks for the derived-types.
#       !
#       real, pointer :: var(:) =>null() ! Comments block for the variables.
#       integer       :: num = 0
#     end type MULTI_ARRAY
#
#   contains
#
#     subroutine hoge( in,   &   ! Comment blocks between continuation lines are ignored.
#         &            out )
#       !
#       ! Comment blocks for the subroutines or functions
#       !
#       character(*),intent(in):: in ! Comment blocks for the arguments.
#       character(*),intent(out),allocatable,target  :: in
#                                    ! Comment blocks can be
#                                    ! written under Fortran statements.
#
#       character(32) :: file ! This comment parsed as a variable in below NAMELIST.
#       integer       :: id
#
#       namelist /varinfo_nml/ file, id
#               !
#               ! Comment blocks for the NAMELISTs.
#               ! Information about variables are described above.
#               !
#
#     ....
#
#     end subroutine hoge
#
#     integer function foo( in )
#       !
#       ! This part is considered as comment block.
#
#       ! Comment blocks under blank lines are ignored.
#       !
#       integer, intent(in):: inA ! This part is considered as comment block.
#
#                                 ! This part is ignored.
#
#     end function foo
#
#     subroutine hide( in,   &
#       &              out )      !:nodoc:
#       !
#       ! If "!:nodoc:" is described at end-of-line in subroutine
#       ! statement as above, the subroutine is ignored.
#       ! This assignment can be used to modules, subroutines,
#       ! functions, variables, constants, derived-types,
#       ! defined operators, defined assignments,
#       ! list of imported modules ("use" statement).
#       !
#
#     ....
#
#     end subroutine hide
#
#   end module hogehoge

class RDoc::Parser::F95 < RDoc::Parser

  parse_files_matching(/\.((f|F)9(0|5)|F)$/)

  class Token

    NO_TEXT = "??".freeze

    def initialize(line_no, char_no)
      @line_no = line_no
      @char_no = char_no
      @text    = NO_TEXT
    end
    # Because we're used in contexts that expect to return a token,
    # we set the text string and then return ourselves
    def set_text(text)
      @text = text
      self
    end

    attr_reader :line_no, :char_no, :text

  end

  @@external_aliases = []
  @@public_methods   = []

  ##
  # "false":: Comments are below source code
  # "true" :: Comments are upper source code

  COMMENTS_ARE_UPPER  = false

  ##
  # Internal alias message

  INTERNAL_ALIAS_MES = "Alias for"

  ##
  # External alias message

  EXTERNAL_ALIAS_MES = "The entity is"

  ##
  # Define code constructs

  def scan
    # remove private comment
    remaining_code = remove_private_comments(@content)

    # continuation lines are united to one line
    remaining_code = united_to_one_line(remaining_code)

    # semicolons are replaced to line feed
    remaining_code = semicolon_to_linefeed(remaining_code)

    # collect comment for file entity
    whole_comment, remaining_code = collect_first_comment(remaining_code)
    @top_level.comment = whole_comment

    # String "remaining_code" is converted to Array "remaining_lines"
    remaining_lines = remaining_code.split("\n")

    # "module" or "program" parts are parsed (new)
    #
    level_depth = 0
    block_searching_flag = nil
    block_searching_lines = []
    pre_comment = []
    module_program_trailing = ""
    module_program_name = ""
    other_block_level_depth = 0
    other_block_searching_flag = nil
    remaining_lines.collect!{|line|
      if !block_searching_flag && !other_block_searching_flag
        if line =~ /^\s*?module\s+(\w+)\s*?(!.*?)?$/i
          block_searching_flag = :module
          block_searching_lines << line
          module_program_name = $1
          module_program_trailing = find_comments($2)
          next false
        elsif line =~ /^\s*?program\s+(\w+)\s*?(!.*?)?$/i ||
               line =~ /^\s*?\w/ && !block_start?(line)
          block_searching_flag = :program
          block_searching_lines << line
          module_program_name = $1 || ""
          module_program_trailing = find_comments($2)
          next false

        elsif block_start?(line)
          other_block_searching_flag = true
          next line

        elsif line =~ /^\s*?!\s?(.*)/
          pre_comment << line
          next line
        else
          pre_comment = []
          next line
        end
      elsif other_block_searching_flag
        other_block_level_depth += 1 if block_start?(line)
        other_block_level_depth -= 1 if block_end?(line)
        if other_block_level_depth < 0
          other_block_level_depth = 0
          other_block_searching_flag = nil
        end
        next line
      end

      block_searching_lines << line
      level_depth += 1 if block_start?(line)
      level_depth -= 1 if block_end?(line)
      if level_depth >= 0
        next false
      end

      # "module_program_code" is formatted.
      # ":nodoc:" flag is checked.
      #
      module_program_code = block_searching_lines.join("\n")
      module_program_code = remove_empty_head_lines(module_program_code)
      if module_program_trailing =~ /^:nodoc:/
        # next loop to search next block
        level_depth = 0
        block_searching_flag = false
        block_searching_lines = []
        pre_comment = []
        next false
      end

      # NormalClass is created, and added to @top_level
      #
      if block_searching_flag == :module
        module_name = module_program_name
        module_code = module_program_code
        module_trailing = module_program_trailing

        f9x_module = @top_level.add_module NormalClass, module_name
        f9x_module.record_location @top_level

        @stats.add_module f9x_module

        f9x_comment = COMMENTS_ARE_UPPER ?
          find_comments(pre_comment.join("\n"))  + "\n" + module_trailing :
            module_trailing + "\n" + find_comments(module_code.sub(/^.*$\n/i, ''))
        f9x_module.comment = f9x_comment
        parse_program_or_module(f9x_module, module_code)

        TopLevel.all_files.each do |name, toplevel|
          if toplevel.include_includes?(module_name, @options.ignore_case)
            if !toplevel.include_requires?(@file_name, @options.ignore_case)
              toplevel.add_require(Require.new(@file_name, ""))
            end
          end
          toplevel.each_classmodule{|m|
            if m.include_includes?(module_name, @options.ignore_case)
              if !m.include_requires?(@file_name, @options.ignore_case)
                m.add_require(Require.new(@file_name, ""))
              end
            end
          }
        end
      elsif block_searching_flag == :program
        program_name = module_program_name
        program_code = module_program_code
        program_trailing = module_program_trailing
        # progress "p" # HACK what stats thingy does this correspond to?
        program_comment = COMMENTS_ARE_UPPER ?
          find_comments(pre_comment.join("\n")) + "\n" + program_trailing :
            program_trailing + "\n" + find_comments(program_code.sub(/^.*$\n/i, ''))
        program_comment = "\n\n= <i>Program</i> <tt>#{program_name}</tt>\n\n" \
                          + program_comment
        @top_level.comment << program_comment
        parse_program_or_module(@top_level, program_code, :private)
      end

      # next loop to search next block
      level_depth = 0
      block_searching_flag = false
      block_searching_lines = []
      pre_comment = []
      next false
    }

    remaining_lines.delete_if{ |line|
      line == false
    }

    # External subprograms and functions are parsed
    #
    parse_program_or_module(@top_level, remaining_lines.join("\n"),
                            :public, true)

    @top_level
  end  # End of scan

  private

  def parse_program_or_module(container, code,
                              visibility=:public, external=nil)
    return unless container
    return unless code
    remaining_lines = code.split("\n")
    remaining_code = "#{code}"

    #
    # Parse variables before "contains" in module
    #
    level_depth = 0
    before_contains_lines = []
    before_contains_code = nil
    before_contains_flag = nil
    remaining_lines.each{ |line|
      if !before_contains_flag
        if line =~ /^\s*?module\s+\w+\s*?(!.*?)?$/i
          before_contains_flag = true
        end
      else
        break if line =~ /^\s*?contains\s*?(!.*?)?$/i
        level_depth += 1 if block_start?(line)
        level_depth -= 1 if block_end?(line)
        break if level_depth < 0
        before_contains_lines << line
      end
    }
    before_contains_code = before_contains_lines.join("\n")
    if before_contains_code
      before_contains_code.gsub!(/^\s*?interface\s+.*?\s+end\s+interface.*?$/im, "")
      before_contains_code.gsub!(/^\s*?type[\s\,]+.*?\s+end\s+type.*?$/im, "")
    end

    #
    # Parse global "use"
    #
    use_check_code = "#{before_contains_code}"
    cascaded_modules_list = []
    while use_check_code =~ /^\s*?use\s+(\w+)(.*?)(!.*?)?$/i
      use_check_code = $~.pre_match
      use_check_code << $~.post_match
      used_mod_name = $1.strip.chomp
      used_list = $2 || ""
      used_trailing = $3 || ""
      next if used_trailing =~ /!:nodoc:/
      if !container.include_includes?(used_mod_name, @options.ignore_case)
        # progress "." # HACK what stats thingy does this correspond to?
        container.add_include Include.new(used_mod_name, "")
      end
      if ! (used_list =~ /\,\s*?only\s*?:/i )
        cascaded_modules_list << "\#" + used_mod_name
      end
    end

    #
    # Parse public and private, and store information.
    # This information is used when "add_method" and
    # "set_visibility_for" are called.
    #
    visibility_default, visibility_info =
              parse_visibility(remaining_lines.join("\n"), visibility, container)
    @@public_methods.concat visibility_info
    if visibility_default == :public
      if !cascaded_modules_list.empty?
        cascaded_modules =
          Attr.new("Cascaded Modules",
                   "Imported modules all of whose components are published again",
                   "",
                   cascaded_modules_list.join(", "))
        container.add_attribute(cascaded_modules)
      end
    end

    #
    # Check rename elements
    #
    use_check_code = "#{before_contains_code}"
    while use_check_code =~ /^\s*?use\s+(\w+)\s*?\,(.+)$/i
      use_check_code = $~.pre_match
      use_check_code << $~.post_match
      used_mod_name = $1.strip.chomp
      used_elements = $2.sub(/\s*?only\s*?:\s*?/i, '')
      used_elements.split(",").each{ |used|
        if /\s*?(\w+)\s*?=>\s*?(\w+)\s*?/ =~ used
          local = $1
          org = $2
          @@public_methods.collect!{ |pub_meth|
            if local == pub_meth["name"] ||
                local.upcase == pub_meth["name"].upcase &&
                @options.ignore_case
              pub_meth["name"] = org
              pub_meth["local_name"] = local
            end
            pub_meth
          }
        end
      }
    end

    #
    # Parse private "use"
    #
    use_check_code = remaining_lines.join("\n")
    while use_check_code =~ /^\s*?use\s+(\w+)(.*?)(!.*?)?$/i
      use_check_code = $~.pre_match
      use_check_code << $~.post_match
      used_mod_name = $1.strip.chomp
      used_trailing = $3 || ""
      next if used_trailing =~ /!:nodoc:/
      if !container.include_includes?(used_mod_name, @options.ignore_case)
        # progress "." # HACK what stats thingy does this correspond to?
        container.add_include Include.new(used_mod_name, "")
      end
    end

    container.each_includes{ |inc|
      TopLevel.all_files.each do |name, toplevel|
        indicated_mod = toplevel.find_symbol(inc.name,
                                             nil, @options.ignore_case)
        if indicated_mod
          indicated_name = indicated_mod.parent.file_relative_name
          if !container.include_requires?(indicated_name, @options.ignore_case)
            container.add_require(Require.new(indicated_name, ""))
          end
          break
        end
      end
    }

    #
    # Parse derived-types definitions
    #
    derived_types_comment = ""
    remaining_code = remaining_lines.join("\n")
    while remaining_code =~ /^\s*?
                                  type[\s\,]+(public|private)?\s*?(::)?\s*?
                                  (\w+)\s*?(!.*?)?$
                                  (.*?)
                                  ^\s*?end\s+type.*?$
                            /imx
      remaining_code = $~.pre_match
      remaining_code << $~.post_match
      typename = $3.chomp.strip
      type_elements = $5 || ""
      type_code = remove_empty_head_lines($&)
      type_trailing = find_comments($4)
      next if type_trailing =~ /^:nodoc:/
      type_visibility = $1
      type_comment = COMMENTS_ARE_UPPER ?
        find_comments($~.pre_match) + "\n" + type_trailing :
          type_trailing + "\n" + find_comments(type_code.sub(/^.*$\n/i, ''))
      type_element_visibility_public = true
      type_code.split("\n").each{ |line|
        if /^\s*?private\s*?$/ =~ line
          type_element_visibility_public = nil
          break
        end
      } if type_code

      args_comment = ""
      type_args_info = nil

      if @options.show_all
        args_comment = find_arguments(nil, type_code, true)
      else
        type_public_args_list = []
        type_args_info = definition_info(type_code)
        type_args_info.each{ |arg|
          arg_is_public = type_element_visibility_public
          arg_is_public = true if arg.include_attr?("public")
          arg_is_public = nil if arg.include_attr?("private")
          type_public_args_list << arg.varname if arg_is_public
        }
        args_comment = find_arguments(type_public_args_list, type_code)
      end

      type = AnyMethod.new("type #{typename}", typename)
      type.singleton = false
      type.params = ""
      type.comment = "<b><em> Derived Type </em></b> :: <tt></tt>\n"
      type.comment << args_comment if args_comment
      type.comment << type_comment if type_comment

      @stats.add_method type

      container.add_method type

      set_visibility(container, typename, visibility_default, @@public_methods)

      if type_visibility
        type_visibility.gsub!(/\s/,'')
        type_visibility.gsub!(/\,/,'')
        type_visibility.gsub!(/:/,'')
        type_visibility.downcase!
        if type_visibility == "public"
          container.set_visibility_for([typename], :public)
        elsif type_visibility == "private"
          container.set_visibility_for([typename], :private)
        end
      end

      check_public_methods(type, container.name)

      if @options.show_all
        derived_types_comment << ", " unless derived_types_comment.empty?
        derived_types_comment << typename
      else
        if type.visibility == :public
        derived_types_comment << ", " unless derived_types_comment.empty?
        derived_types_comment << typename
        end
      end

    end

    if !derived_types_comment.empty?
      derived_types_table =
        Attr.new("Derived Types", "Derived_Types", "",
                 derived_types_comment)
      container.add_attribute(derived_types_table)
    end

    #
    # move interface scope
    #
    interface_code = ""
    while remaining_code =~ /^\s*?
                                 interface(
                                            \s+\w+                      |
                                            \s+operator\s*?\(.*?\)       |
                                            \s+assignment\s*?\(\s*?=\s*?\)
                                          )?\s*?$
                                 (.*?)
                                 ^\s*?end\s+interface.*?$
                            /imx
      interface_code << remove_empty_head_lines($&) + "\n"
      remaining_code = $~.pre_match
      remaining_code << $~.post_match
    end

    #
    # Parse global constants or variables in modules
    #
    const_var_defs = definition_info(before_contains_code)
    const_var_defs.each{|defitem|
      next if defitem.nodoc
      const_or_var_type = "Variable"
      const_or_var_progress = "v"
      if defitem.include_attr?("parameter")
        const_or_var_type = "Constant"
        const_or_var_progress = "c"
      end
      const_or_var = AnyMethod.new(const_or_var_type, defitem.varname)
      const_or_var.singleton = false
      const_or_var.params = ""
      self_comment = find_arguments([defitem.varname], before_contains_code)
      const_or_var.comment = "<b><em>" + const_or_var_type + "</em></b> :: <tt></tt>\n"
      const_or_var.comment << self_comment if self_comment

      @stats.add_method const_or_var_progress

      container.add_method const_or_var

      set_visibility(container, defitem.varname, visibility_default, @@public_methods)

      if defitem.include_attr?("public")
        container.set_visibility_for([defitem.varname], :public)
      elsif defitem.include_attr?("private")
        container.set_visibility_for([defitem.varname], :private)
      end

      check_public_methods(const_or_var, container.name)

    } if const_var_defs

    remaining_lines = remaining_code.split("\n")

    # "subroutine" or "function" parts are parsed (new)
    #
    level_depth = 0
    block_searching_flag = nil
    block_searching_lines = []
    pre_comment = []
    procedure_trailing = ""
    procedure_name = ""
    procedure_params = ""
    procedure_prefix = ""
    procedure_result_arg = ""
    procedure_type = ""
    contains_lines = []
    contains_flag = nil
    remaining_lines.collect!{|line|
      if !block_searching_flag
        # subroutine
        if line =~ /^\s*?
                         (recursive|pure|elemental)?\s*?
                         subroutine\s+(\w+)\s*?(\(.*?\))?\s*?(!.*?)?$
                   /ix
          block_searching_flag = :subroutine
          block_searching_lines << line

          procedure_name = $2.chomp.strip
          procedure_params = $3 || ""
          procedure_prefix = $1 || ""
          procedure_trailing = $4 || "!"
          next false

        # function
        elsif line =~ /^\s*?
                       (recursive|pure|elemental)?\s*?
                       (
                           character\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                         | type\s*?\([\w\s]+?\)\s+
                         | integer\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                         | real\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                         | double\s+precision\s+
                         | logical\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                         | complex\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                       )?
                       function\s+(\w+)\s*?
                       (\(.*?\))?(\s+result\((.*?)\))?\s*?(!.*?)?$
                      /ix
          block_searching_flag = :function
          block_searching_lines << line

          procedure_prefix = $1 || ""
          procedure_type = $2 ? $2.chomp.strip : nil
          procedure_name = $8.chomp.strip
          procedure_params = $9 || ""
          procedure_result_arg = $11 ? $11.chomp.strip : procedure_name
          procedure_trailing = $12 || "!"
          next false
        elsif line =~ /^\s*?!\s?(.*)/
          pre_comment << line
          next line
        else
          pre_comment = []
          next line
        end
      end
      contains_flag = true if line =~ /^\s*?contains\s*?(!.*?)?$/
      block_searching_lines << line
      contains_lines << line if contains_flag

      level_depth += 1 if block_start?(line)
      level_depth -= 1 if block_end?(line)
      if level_depth >= 0
        next false
      end

      # "procedure_code" is formatted.
      # ":nodoc:" flag is checked.
      #
      procedure_code = block_searching_lines.join("\n")
      procedure_code = remove_empty_head_lines(procedure_code)
      if procedure_trailing =~ /^!:nodoc:/
        # next loop to search next block
        level_depth = 0
        block_searching_flag = nil
        block_searching_lines = []
        pre_comment = []
        procedure_trailing = ""
        procedure_name = ""
        procedure_params = ""
        procedure_prefix = ""
        procedure_result_arg = ""
        procedure_type = ""
        contains_lines = []
        contains_flag = nil
        next false
      end

      # AnyMethod is created, and added to container
      #
      subroutine_function = nil
      if block_searching_flag == :subroutine
        subroutine_prefix   = procedure_prefix
        subroutine_name     = procedure_name
        subroutine_params   = procedure_params
        subroutine_trailing = procedure_trailing
        subroutine_code     = procedure_code

        subroutine_comment = COMMENTS_ARE_UPPER ?
          pre_comment.join("\n") + "\n" + subroutine_trailing :
            subroutine_trailing + "\n" + subroutine_code.sub(/^.*$\n/i, '')
        subroutine = AnyMethod.new("subroutine", subroutine_name)
        parse_subprogram(subroutine, subroutine_params,
                         subroutine_comment, subroutine_code,
                         before_contains_code, nil, subroutine_prefix)

        @stats.add_method subroutine

        container.add_method subroutine
        subroutine_function = subroutine

      elsif block_searching_flag == :function
        function_prefix     = procedure_prefix
        function_type       = procedure_type
        function_name       = procedure_name
        function_params_org = procedure_params
        function_result_arg = procedure_result_arg
        function_trailing   = procedure_trailing
        function_code_org   = procedure_code

        function_comment = COMMENTS_ARE_UPPER ?
          pre_comment.join("\n") + "\n" + function_trailing :
            function_trailing + "\n " + function_code_org.sub(/^.*$\n/i, '')

        function_code = "#{function_code_org}"
        if function_type
          function_code << "\n" + function_type + " :: " + function_result_arg
        end

        function_params =
          function_params_org.sub(/^\(/, "\(#{function_result_arg}, ")

        function = AnyMethod.new("function", function_name)
        parse_subprogram(function, function_params,
                         function_comment, function_code,
                         before_contains_code, true, function_prefix)

        # Specific modification due to function
        function.params.sub!(/\(\s*?#{function_result_arg}\s*?,\s*?/, "\( ")
        function.params << " result(" + function_result_arg + ")"
        function.start_collecting_tokens
        function.add_token Token.new(1,1).set_text(function_code_org)

        @stats.add_method function

        container.add_method function
        subroutine_function = function

      end

      # The visibility of procedure is specified
      #
      set_visibility(container, procedure_name,
                     visibility_default, @@public_methods)

      # The alias for this procedure from external modules
      #
      check_external_aliases(procedure_name,
                             subroutine_function.params,
                             subroutine_function.comment, subroutine_function) if external
      check_public_methods(subroutine_function, container.name)


      # contains_lines are parsed as private procedures
      if contains_flag
        parse_program_or_module(container,
                                contains_lines.join("\n"), :private)
      end

      # next loop to search next block
      level_depth = 0
      block_searching_flag = nil
      block_searching_lines = []
      pre_comment = []
      procedure_trailing = ""
      procedure_name = ""
      procedure_params = ""
      procedure_prefix = ""
      procedure_result_arg = ""
      contains_lines = []
      contains_flag = nil
      next false
    } # End of remaining_lines.collect!{|line|

    # Array remains_lines is converted to String remains_code again
    #
    remaining_code = remaining_lines.join("\n")

    #
    # Parse interface
    #
    interface_scope = false
    generic_name = ""
    interface_code.split("\n").each{ |line|
      if /^\s*?
               interface(
                          \s+\w+|
                          \s+operator\s*?\(.*?\)|
                          \s+assignment\s*?\(\s*?=\s*?\)
                        )?
               \s*?(!.*?)?$
         /ix =~ line
        generic_name = $1 ? $1.strip.chomp : nil
        interface_trailing = $2 || "!"
        interface_scope = true
        interface_scope = false if interface_trailing =~ /!:nodoc:/
#        if generic_name =~ /operator\s*?\((.*?)\)/i
#          operator_name = $1
#          if operator_name && !operator_name.empty?
#            generic_name = "#{operator_name}"
#          end
#        end
#        if generic_name =~ /assignment\s*?\((.*?)\)/i
#          assignment_name = $1
#          if assignment_name && !assignment_name.empty?
#            generic_name = "#{assignment_name}"
#          end
#        end
      end
      if /^\s*?end\s+interface/i =~ line
        interface_scope = false
        generic_name = nil
      end
      # internal alias
      if interface_scope && /^\s*?module\s+procedure\s+(.*?)(!.*?)?$/i =~ line
        procedures = $1.strip.chomp
        procedures_trailing = $2 || "!"
        next if procedures_trailing =~ /!:nodoc:/
        procedures.split(",").each{ |proc|
          proc.strip!
          proc.chomp!
          next if generic_name == proc || !generic_name
          old_meth = container.find_symbol(proc, nil, @options.ignore_case)
          next if !old_meth
          nolink = old_meth.visibility == :private ? true : nil
          nolink = nil if @options.show_all
          new_meth =
             initialize_external_method(generic_name, proc,
                                        old_meth.params, nil,
                                        old_meth.comment,
                                        old_meth.clone.token_stream[0].text,
                                        true, nolink)
          new_meth.singleton = old_meth.singleton

          @stats.add_method new_meth

          container.add_method new_meth

          set_visibility(container, generic_name, visibility_default, @@public_methods)

          check_public_methods(new_meth, container.name)

        }
      end

      # external aliases
      if interface_scope
        # subroutine
        proc = nil
        params = nil
        procedures_trailing = nil
        if line =~ /^\s*?
                         (recursive|pure|elemental)?\s*?
                         subroutine\s+(\w+)\s*?(\(.*?\))?\s*?(!.*?)?$
                   /ix
          proc = $2.chomp.strip
          generic_name = proc unless generic_name
          params = $3 || ""
          procedures_trailing = $4 || "!"

        # function
        elsif line =~ /^\s*?
                       (recursive|pure|elemental)?\s*?
                       (
                           character\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                         | type\s*?\([\w\s]+?\)\s+
                         | integer\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                         | real\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                         | double\s+precision\s+
                         | logical\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                         | complex\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                       )?
                       function\s+(\w+)\s*?
                       (\(.*?\))?(\s+result\((.*?)\))?\s*?(!.*?)?$
                      /ix
          proc = $8.chomp.strip
          generic_name = proc unless generic_name
          params = $9 || ""
          procedures_trailing = $12 || "!"
        else
          next
        end
        next if procedures_trailing =~ /!:nodoc:/
        indicated_method = nil
        indicated_file   = nil
        TopLevel.all_files.each do |name, toplevel|
          indicated_method = toplevel.find_local_symbol(proc, @options.ignore_case)
          indicated_file = name
          break if indicated_method
        end

        if indicated_method
          external_method =
            initialize_external_method(generic_name, proc,
                                       indicated_method.params,
                                       indicated_file,
                                       indicated_method.comment)

          @stats.add_method external_method

          container.add_method external_method
          set_visibility(container, generic_name, visibility_default, @@public_methods)
          if !container.include_requires?(indicated_file, @options.ignore_case)
            container.add_require(Require.new(indicated_file, ""))
          end
          check_public_methods(external_method, container.name)

        else
          @@external_aliases << {
            "new_name"  => generic_name,
            "old_name"  => proc,
            "file_or_module" => container,
            "visibility" => find_visibility(container, generic_name, @@public_methods) || visibility_default
          }
        end
      end

    } if interface_code # End of interface_code.split("\n").each ...

    #
    # Already imported methods are removed from @@public_methods.
    # Remainders are assumed to be imported from other modules.
    #
    @@public_methods.delete_if{ |method| method["entity_is_discovered"]}

    @@public_methods.each{ |pub_meth|
      next unless pub_meth["file_or_module"].name == container.name
      pub_meth["used_modules"].each{ |used_mod|
        TopLevel.all_classes_and_modules.each{ |modules|
          if modules.name == used_mod ||
              modules.name.upcase == used_mod.upcase &&
              @options.ignore_case
            modules.method_list.each{ |meth|
              if meth.name == pub_meth["name"] ||
                  meth.name.upcase == pub_meth["name"].upcase &&
                  @options.ignore_case
                new_meth = initialize_public_method(meth,
                                                    modules.name)
                if pub_meth["local_name"]
                  new_meth.name = pub_meth["local_name"]
                end

                @stats.add_method new_meth

                container.add_method new_meth
              end
            }
          end
        }
      }
    }

    container
  end  # End of parse_program_or_module

  ##
  # Parse arguments, comment, code of subroutine and function.  Return
  # AnyMethod object.

  def parse_subprogram(subprogram, params, comment, code,
                       before_contains=nil, function=nil, prefix=nil)
    subprogram.singleton = false
    prefix = "" if !prefix
    arguments = params.sub(/\(/, "").sub(/\)/, "").split(",") if params
    args_comment, params_opt =
      find_arguments(arguments, code.sub(/^s*?contains\s*?(!.*?)?$.*/im, ""),
                     nil, nil, true)
    params_opt = "( " + params_opt + " ) " if params_opt
    subprogram.params = params_opt || ""
    namelist_comment = find_namelists(code, before_contains)

    block_comment = find_comments comment
    if function
      subprogram.comment = "<b><em> Function </em></b> :: <em>#{prefix}</em>\n"
    else
      subprogram.comment = "<b><em> Subroutine </em></b> :: <em>#{prefix}</em>\n"
    end
    subprogram.comment << args_comment if args_comment
    subprogram.comment << block_comment if block_comment
    subprogram.comment << namelist_comment if namelist_comment

    # For output source code
    subprogram.start_collecting_tokens
    subprogram.add_token Token.new(1,1).set_text(code)

    subprogram
  end

  ##
  # Collect comment for file entity

  def collect_first_comment(body)
    comment = ""
    not_comment = ""
    comment_start = false
    comment_end   = false
    body.split("\n").each{ |line|
      if comment_end
        not_comment << line
        not_comment << "\n"
      elsif /^\s*?!\s?(.*)$/i =~ line
        comment_start = true
        comment << $1
        comment << "\n"
      elsif /^\s*?$/i =~ line
        comment_end = true if comment_start && COMMENTS_ARE_UPPER
      else
        comment_end = true
        not_comment << line
        not_comment << "\n"
      end
    }
    return comment, not_comment
  end


  ##
  # Return comments of definitions of arguments
  #
  # If "all" argument is true, information of all arguments are returned.
  #
  # If "modified_params" is true, list of arguments are decorated, for
  # example, optional arguments are parenthetic as "[arg]".

  def find_arguments(args, text, all=nil, indent=nil, modified_params=nil)
    return unless args || all
    indent = "" unless indent
    args = ["all"] if all
    params = "" if modified_params
    comma = ""
    return unless text
    args_rdocforms = "\n"
    remaining_lines = "#{text}"
    definitions = definition_info(remaining_lines)
    args.each{ |arg|
      arg.strip!
      arg.chomp!
      definitions.each { |defitem|
        if arg == defitem.varname.strip.chomp || all
          args_rdocforms << <<-"EOF"

#{indent}<tt><b>#{defitem.varname.chomp.strip}#{defitem.arraysuffix}</b> #{defitem.inivalue}</tt> ::
#{indent}   <tt>#{defitem.types.chomp.strip}</tt>
EOF
          if !defitem.comment.chomp.strip.empty?
            comment = ""
            defitem.comment.split("\n").each{ |line|
              comment << "       " + line + "\n"
            }
            args_rdocforms << <<-"EOF"

#{indent}   <tt></tt> ::
#{indent}       <tt></tt>
#{indent}       #{comment.chomp.strip}
EOF
          end

          if modified_params
            if defitem.include_attr?("optional")
              params << "#{comma}[#{arg}]"
            else
              params << "#{comma}#{arg}"
            end
            comma = ", "
          end
        end
      }
    }
    if modified_params
      return args_rdocforms, params
    else
      return args_rdocforms
    end
  end

  ##
  # Return comments of definitions of namelists

  def find_namelists(text, before_contains=nil)
    return nil if !text
    result = ""
    lines = "#{text}"
    before_contains = "" if !before_contains
    while lines =~ /^\s*?namelist\s+\/\s*?(\w+)\s*?\/([\s\w\,]+)$/i
      lines = $~.post_match
      nml_comment = COMMENTS_ARE_UPPER ?
          find_comments($~.pre_match) : find_comments($~.post_match)
      nml_name = $1
      nml_args = $2.split(",")
      result << "\n\n=== NAMELIST <tt><b>" + nml_name + "</tt></b>\n\n"
      result << nml_comment + "\n" if nml_comment
      if lines.split("\n")[0] =~ /^\//i
        lines = "namelist " + lines
      end
      result << find_arguments(nml_args, "#{text}" + "\n" + before_contains)
    end
    return result
  end

  ##
  # Comments just after module or subprogram, or arguments are returned. If
  # "COMMENTS_ARE_UPPER" is true, comments just before modules or subprograms
  # are returnd

  def find_comments text
    return "" unless text
    lines = text.split("\n")
    lines.reverse! if COMMENTS_ARE_UPPER
    comment_block = Array.new
    lines.each do |line|
      break if line =~ /^\s*?\w/ || line =~ /^\s*?$/
      if COMMENTS_ARE_UPPER
        comment_block.unshift line.sub(/^\s*?!\s?/,"")
      else
        comment_block.push line.sub(/^\s*?!\s?/,"")
      end
    end
    nice_lines = comment_block.join("\n").split "\n\s*?\n"
    nice_lines[0] ||= ""
    nice_lines.shift
  end

  ##
  # Create method for internal alias

  def initialize_public_method(method, parent)
    return if !method || !parent

    new_meth = AnyMethod.new("External Alias for module", method.name)
    new_meth.singleton    = method.singleton
    new_meth.params       = method.params.clone
    new_meth.comment      = remove_trailing_alias(method.comment.clone)
    new_meth.comment      << "\n\n#{EXTERNAL_ALIAS_MES} #{parent.strip.chomp}\##{method.name}"

    return new_meth
  end

  ##
  # Create method for external alias
  #
  # If argument "internal" is true, file is ignored.

  def initialize_external_method(new, old, params, file, comment, token=nil,
                                 internal=nil, nolink=nil)
    return nil unless new || old

    if internal
      external_alias_header = "#{INTERNAL_ALIAS_MES} "
      external_alias_text   = external_alias_header + old
    elsif file
      external_alias_header = "#{EXTERNAL_ALIAS_MES} "
      external_alias_text   = external_alias_header + file + "#" + old
    else
      return nil
    end
    external_meth = AnyMethod.new(external_alias_text, new)
    external_meth.singleton    = false
    external_meth.params       = params
    external_comment = remove_trailing_alias(comment) + "\n\n" if comment
    external_meth.comment = external_comment || ""
    if nolink && token
      external_meth.start_collecting_tokens
      external_meth.add_token Token.new(1,1).set_text(token)
    else
      external_meth.comment << external_alias_text
    end

    return external_meth
  end

  ##
  # Parse visibility

  def parse_visibility(code, default, container)
    result = []
    visibility_default = default || :public

    used_modules = []
    container.includes.each{|i| used_modules << i.name} if container

    remaining_code = code.gsub(/^\s*?type[\s\,]+.*?\s+end\s+type.*?$/im, "")
    remaining_code.split("\n").each{ |line|
      if /^\s*?private\s*?$/ =~ line
        visibility_default = :private
        break
      end
    } if remaining_code

    remaining_code.split("\n").each{ |line|
      if /^\s*?private\s*?(::)?\s+(.*)\s*?(!.*?)?/i =~ line
        methods = $2.sub(/!.*$/, '')
        methods.split(",").each{ |meth|
          meth.sub!(/!.*$/, '')
          meth.gsub!(/:/, '')
          result << {
            "name" => meth.chomp.strip,
            "visibility" => :private,
            "used_modules" => used_modules.clone,
            "file_or_module" => container,
            "entity_is_discovered" => nil,
            "local_name" => nil
          }
        }
      elsif /^\s*?public\s*?(::)?\s+(.*)\s*?(!.*?)?/i =~ line
        methods = $2.sub(/!.*$/, '')
        methods.split(",").each{ |meth|
          meth.sub!(/!.*$/, '')
          meth.gsub!(/:/, '')
          result << {
            "name" => meth.chomp.strip,
            "visibility" => :public,
            "used_modules" => used_modules.clone,
            "file_or_module" => container,
            "entity_is_discovered" => nil,
            "local_name" => nil
          }
        }
      end
    } if remaining_code

    if container
      result.each{ |vis_info|
        vis_info["parent"] = container.name
      }
    end

    return visibility_default, result
  end

  ##
  # Set visibility
  #
  # "subname" element of "visibility_info" is deleted.

  def set_visibility(container, subname, visibility_default, visibility_info)
    return unless container || subname || visibility_default || visibility_info
    not_found = true
    visibility_info.collect!{ |info|
      if info["name"] == subname ||
          @options.ignore_case && info["name"].upcase == subname.upcase
        if info["file_or_module"].name == container.name
          container.set_visibility_for([subname], info["visibility"])
          info["entity_is_discovered"] = true
          not_found = false
        end
      end
      info
    }
    if not_found
      return container.set_visibility_for([subname], visibility_default)
    else
      return container
    end
  end

  ##
  # Find visibility

  def find_visibility(container, subname, visibility_info)
    return nil if !subname || !visibility_info
    visibility_info.each{ |info|
      if info["name"] == subname ||
          @options.ignore_case && info["name"].upcase == subname.upcase
        if info["parent"] == container.name
          return info["visibility"]
        end
      end
    }
    return nil
  end

  ##
  # Check external aliases

  def check_external_aliases(subname, params, comment, test=nil)
    @@external_aliases.each{ |alias_item|
      if subname == alias_item["old_name"] ||
                  subname.upcase == alias_item["old_name"].upcase &&
                          @options.ignore_case

        new_meth = initialize_external_method(alias_item["new_name"],
                                              subname, params, @file_name,
                                              comment)
        new_meth.visibility = alias_item["visibility"]

        @stats.add_method new_meth

        alias_item["file_or_module"].add_method(new_meth)

        if !alias_item["file_or_module"].include_requires?(@file_name, @options.ignore_case)
          alias_item["file_or_module"].add_require(Require.new(@file_name, ""))
        end
      end
    }
  end

  ##
  # Check public_methods

  def check_public_methods(method, parent)
    return if !method || !parent
    @@public_methods.each{ |alias_item|
      parent_is_used_module = nil
      alias_item["used_modules"].each{ |used_module|
        if used_module == parent ||
            used_module.upcase == parent.upcase &&
            @options.ignore_case
          parent_is_used_module = true
        end
      }
      next if !parent_is_used_module

      if method.name == alias_item["name"] ||
          method.name.upcase == alias_item["name"].upcase &&
          @options.ignore_case

        new_meth = initialize_public_method(method, parent)
        if alias_item["local_name"]
          new_meth.name = alias_item["local_name"]
        end

        @stats.add_method new_meth

        alias_item["file_or_module"].add_method new_meth
      end
    }
  end

  ##
  # Continuous lines are united.
  #
  # Comments in continuous lines are removed.

  def united_to_one_line(f90src)
    return "" unless f90src
    lines = f90src.split("\n")
    previous_continuing = false
    now_continuing = false
    body = ""
    lines.each{ |line|
      words = line.split("")
      next if words.empty? && previous_continuing
      commentout = false
      brank_flag = true ; brank_char = ""
      squote = false    ; dquote = false
      ignore = false
      words.collect! { |char|
        if previous_continuing && brank_flag
          now_continuing = true
          ignore         = true
          case char
          when "!"                       ; break
          when " " ; brank_char << char  ; next ""
          when "&"
            brank_flag = false
            now_continuing = false
            next ""
          else
            brank_flag     = false
            now_continuing = false
            ignore         = false
            next brank_char + char
          end
        end
        ignore = false

        if now_continuing
          next ""
        elsif !(squote) && !(dquote) && !(commentout)
          case char
          when "!" ; commentout = true     ; next char
          when "\""; dquote = true         ; next char
          when "\'"; squote = true         ; next char
          when "&" ; now_continuing = true ; next ""
          else next char
          end
        elsif commentout
          next char
        elsif squote
          case char
          when "\'"; squote = false ; next char
          else next char
          end
        elsif dquote
          case char
          when "\""; dquote = false ; next char
          else next char
          end
        end
      }
      if !ignore && !previous_continuing || !brank_flag
        if previous_continuing
          body << words.join("")
        else
          body << "\n" + words.join("")
        end
      end
      previous_continuing = now_continuing ? true : nil
      now_continuing = nil
    }
    return body
  end


  ##
  # Continuous line checker

  def continuous_line?(line)
    continuous = false
    if /&\s*?(!.*)?$/ =~ line
      continuous = true
      if comment_out?($~.pre_match)
        continuous = false
      end
    end
    return continuous
  end

  ##
  # Comment out checker

  def comment_out?(line)
    return nil unless line
    commentout = false
    squote = false ; dquote = false
    line.split("").each { |char|
      if !(squote) && !(dquote)
        case char
        when "!" ; commentout = true ; break
        when "\""; dquote = true
        when "\'"; squote = true
        else next
        end
      elsif squote
        case char
        when "\'"; squote = false
        else next
        end
      elsif dquote
        case char
        when "\""; dquote = false
        else next
        end
      end
    }
    return commentout
  end

  ##
  # Semicolons are replaced to line feed.

  def semicolon_to_linefeed(text)
    return "" unless text
    lines = text.split("\n")
    lines.collect!{ |line|
      words = line.split("")
      commentout = false
      squote = false ; dquote = false
      words.collect! { |char|
        if !(squote) && !(dquote) && !(commentout)
          case char
          when "!" ; commentout = true ; next char
          when "\""; dquote = true     ; next char
          when "\'"; squote = true     ; next char
          when ";" ;                     "\n"
          else next char
          end
        elsif commentout
          next char
        elsif squote
          case char
          when "\'"; squote = false ; next char
          else next char
          end
        elsif dquote
          case char
          when "\""; dquote = false ; next char
          else next char
          end
        end
      }
      words.join("")
    }
    return lines.join("\n")
  end

  ##
  # Which "line" is start of block (module, program, block data, subroutine,
  # function) statement ?

  def block_start?(line)
    return nil if !line

    if line =~ /^\s*?module\s+(\w+)\s*?(!.*?)?$/i    ||
        line =~ /^\s*?program\s+(\w+)\s*?(!.*?)?$/i  ||
        line =~ /^\s*?block\s+data(\s+\w+)?\s*?(!.*?)?$/i     ||
        line =~ \
                /^\s*?
                 (recursive|pure|elemental)?\s*?
                 subroutine\s+(\w+)\s*?(\(.*?\))?\s*?(!.*?)?$
                /ix ||
        line =~ \
                /^\s*?
                 (recursive|pure|elemental)?\s*?
                 (
                     character\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                   | type\s*?\([\w\s]+?\)\s+
                   | integer\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                   | real\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                   | double\s+precision\s+
                   | logical\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                   | complex\s*?(\([\w\s\=\(\)\*]+?\))?\s+
                 )?
                 function\s+(\w+)\s*?
                 (\(.*?\))?(\s+result\((.*?)\))?\s*?(!.*?)?$
                /ix
      return true
    end

    return nil
  end

  ##
  # Which "line" is end of block (module, program, block data, subroutine,
  # function) statement ?

  def block_end?(line)
    return nil if !line

    if line =~ /^\s*?end\s*?(!.*?)?$/i                 ||
        line =~ /^\s*?end\s+module(\s+\w+)?\s*?(!.*?)?$/i       ||
        line =~ /^\s*?end\s+program(\s+\w+)?\s*?(!.*?)?$/i      ||
        line =~ /^\s*?end\s+block\s+data(\s+\w+)?\s*?(!.*?)?$/i  ||
        line =~ /^\s*?end\s+subroutine(\s+\w+)?\s*?(!.*?)?$/i   ||
        line =~ /^\s*?end\s+function(\s+\w+)?\s*?(!.*?)?$/i
      return true
    end

    return nil
  end

  ##
  # Remove "Alias for" in end of comments

  def remove_trailing_alias(text)
    return "" if !text
    lines = text.split("\n").reverse
    comment_block = Array.new
    checked = false
    lines.each do |line|
      if !checked
        if /^\s?#{INTERNAL_ALIAS_MES}/ =~ line ||
            /^\s?#{EXTERNAL_ALIAS_MES}/ =~ line
          checked = true
          next
        end
      end
      comment_block.unshift line
    end
    nice_lines = comment_block.join("\n")
    nice_lines ||= ""
    return nice_lines
  end

  ##
  # Empty lines in header are removed

  def remove_empty_head_lines(text)
    return "" unless text
    lines = text.split("\n")
    header = true
    lines.delete_if{ |line|
      header = false if /\S/ =~ line
      header && /^\s*?$/ =~ line
    }
    lines.join("\n")
  end

  ##
  # header marker "=", "==", ... are removed

  def remove_header_marker(text)
    return text.gsub(/^\s?(=+)/, '<tt></tt>\1')
  end

  def remove_private_comments(body)
    body.gsub!(/^\s*!--\s*?$.*?^\s*!\+\+\s*?$/m, '')
    return body
  end

  ##
  # Information of arguments of subroutines and functions in Fortran95

  class Fortran95Definition

    # Name of variable
    #
    attr_reader   :varname

    # Types of variable
    #
    attr_reader   :types

    # Initial Value
    #
    attr_reader   :inivalue

    # Suffix of array
    #
    attr_reader   :arraysuffix

    # Comments
    #
    attr_accessor   :comment

    # Flag of non documentation
    #
    attr_accessor   :nodoc

    def initialize(varname, types, inivalue, arraysuffix, comment,
                   nodoc=false)
      @varname = varname
      @types = types
      @inivalue = inivalue
      @arraysuffix = arraysuffix
      @comment = comment
      @nodoc = nodoc
    end

    def to_s
      return <<-EOF
<Fortran95Definition:
varname=#{@varname}, types=#{types},
inivalue=#{@inivalue}, arraysuffix=#{@arraysuffix}, nodoc=#{@nodoc},
comment=
#{@comment}
>
EOF
    end

    #
    # If attr is included, true is returned
    #
    def include_attr?(attr)
      return if !attr
      @types.split(",").each{ |type|
        return true if type.strip.chomp.upcase == attr.strip.chomp.upcase
      }
      return nil
    end

  end # End of Fortran95Definition

  ##
  # Parse string argument "text", and Return Array of Fortran95Definition
  # object

  def definition_info(text)
    return nil unless text
    lines = "#{text}"
    defs = Array.new
    comment = ""
    trailing_comment = ""
    under_comment_valid = false
    lines.split("\n").each{ |line|
      if /^\s*?!\s?(.*)/ =~ line
        if COMMENTS_ARE_UPPER
          comment << remove_header_marker($1)
          comment << "\n"
        elsif defs[-1] && under_comment_valid
          defs[-1].comment << "\n"
          defs[-1].comment << remove_header_marker($1)
        end
        next
      elsif /^\s*?$/ =~ line
        comment = ""
        under_comment_valid = false
        next
      end
      type = ""
      characters = ""
      if line =~ /^\s*?
                  (
                      character\s*?(\([\w\s\=\(\)\*]+?\))?[\s\,]*
                    | type\s*?\([\w\s]+?\)[\s\,]*
                    | integer\s*?(\([\w\s\=\(\)\*]+?\))?[\s\,]*
                    | real\s*?(\([\w\s\=\(\)\*]+?\))?[\s\,]*
                    | double\s+precision[\s\,]*
                    | logical\s*?(\([\w\s\=\(\)\*]+?\))?[\s\,]*
                    | complex\s*?(\([\w\s\=\(\)\*]+?\))?[\s\,]*
                  )
                  (.*?::)?
                  (.+)$
                 /ix
        characters = $8
        type = $1
        type << $7.gsub(/::/, '').gsub(/^\s*?\,/, '') if $7
      else
        under_comment_valid = false
        next
      end
      squote = false ; dquote = false ; bracket = 0
      iniflag = false; commentflag = false
      varname = "" ; arraysuffix = "" ; inivalue = ""
      start_pos = defs.size
      characters.split("").each { |char|
        if !(squote) && !(dquote) && bracket <= 0 && !(iniflag) && !(commentflag)
          case char
          when "!" ; commentflag = true
          when "(" ; bracket += 1       ; arraysuffix = char
          when "\""; dquote = true
          when "\'"; squote = true
          when "=" ; iniflag = true     ; inivalue << char
          when ","
            defs << Fortran95Definition.new(varname, type, inivalue, arraysuffix, comment)
            varname = "" ; arraysuffix = "" ; inivalue = ""
            under_comment_valid = true
          when " " ; next
          else     ; varname << char
          end
        elsif commentflag
          comment << remove_header_marker(char)
          trailing_comment << remove_header_marker(char)
        elsif iniflag
          if dquote
            case char
            when "\"" ; dquote = false ; inivalue << char
            else      ; inivalue << char
            end
          elsif squote
            case char
            when "\'" ; squote = false ; inivalue << char
            else      ; inivalue << char
            end
          elsif bracket > 0
            case char
            when "(" ; bracket += 1 ; inivalue << char
            when ")" ; bracket -= 1 ; inivalue << char
            else     ; inivalue << char
            end
          else
            case char
            when ","
              defs << Fortran95Definition.new(varname, type, inivalue, arraysuffix, comment)
              varname = "" ; arraysuffix = "" ; inivalue = ""
              iniflag = false
              under_comment_valid = true
            when "(" ; bracket += 1 ; inivalue << char
            when "\""; dquote = true  ; inivalue << char
            when "\'"; squote = true  ; inivalue << char
            when "!" ; commentflag = true
            else     ; inivalue << char
            end
          end
        elsif !(squote) && !(dquote) && bracket > 0
          case char
          when "(" ; bracket += 1 ; arraysuffix << char
          when ")" ; bracket -= 1 ; arraysuffix << char
          else     ; arraysuffix << char
          end
        elsif squote
          case char
          when "\'"; squote = false ; inivalue << char
          else     ; inivalue << char
          end
        elsif dquote
          case char
          when "\""; dquote = false ; inivalue << char
          else     ; inivalue << char
          end
        end
      }
      defs << Fortran95Definition.new(varname, type, inivalue, arraysuffix, comment)
      if trailing_comment =~ /^:nodoc:/
        defs[start_pos..-1].collect!{ |defitem|
          defitem.nodoc = true
        }
      end
      varname = "" ; arraysuffix = "" ; inivalue = ""
      comment = ""
      under_comment_valid = true
      trailing_comment = ""
    }
    return defs
  end

end