rdoc 2.0.0

data/lib/rdoc/parsers/parse_f95.rb

@@ -0,0 +1,1841 @@
+#= parse_f95.rb - Fortran95 Parser
+#
+#== Overview
+#
+#"parse_f95.rb" 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
+#
+#"parse_f95.rb" 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
+#
+
+
+require "rdoc/code_objects"
+
+module RDoc
+
+  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
+
+  # See rdoc/parsers/parse_f95.rb
+
+  class Fortran95parser
+
+    extend ParserFactory
+    parse_files_matching(/\.((f|F)9(0|5)|F)$/)
+
+    @@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"
+
+    # prepare to parse a Fortran 95 file
+    def initialize(top_level, file_name, body, options, stats)
+      @body = body
+      @stats = stats
+      @file_name  = file_name
+      @options = options
+      @top_level = top_level
+      @progress = $stderr unless options.quiet
+    end
+
+    # devine code constructs
+    def scan
+
+      # remove private comment
+      remaining_code = remove_private_comments(@body)
+
+      # 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
+          progress "m"
+          @stats.num_modules += 1
+          f9x_module = @top_level.add_module NormalClass, module_name
+          f9x_module.record_location @top_level
+
+          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"
+          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 "."
+          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 "."
+          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
+        progress "t"
+        @stats.num_methods += 1
+        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
+        progress const_or_var_progress
+        @stats.num_methods += 1
+        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)
+          progress "s"
+          @stats.num_methods += 1
+          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)
+
+          progress "f"
+          @stats.num_methods += 1
+          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
+
+            progress "i"
+            @stats.num_methods += 1
+            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)
+
+            progress "e"
+            @stats.num_methods += 1
+            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
+                  progress "e"
+                  @stats.num_methods += 1
+                  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 exameple, 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
+    # returnd. 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
+
+    def progress(char)
+      unless @options.quiet
+        @progress.print(char)
+        @progress.flush
+      end
+    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"]
+
+          progress "e"
+          @stats.num_methods += 1
+          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
+
+          progress "e"
+          @stats.num_methods += 1
+          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 # class Fortran95parser
+
+end # module RDoc