mdextab 0.1.0 → 0.1.3

data/lib/mdextab.rb

@@ -1,615 +1,500 @@
-require "mdextab/version"
-
-require 'mdextab/loggerx'
-require 'mdextab/token'
-require 'mdextab/table'
-require 'mdextab/tbody'
-require 'mdextab/td'
-require 'mdextab/th'
-require 'mdextab/token'
-require 'mdextab/tr'
-require 'mdextab/yamlx'
-
-require 'byebug'
-
+# coding: utf-8
+#
+# MarkDownテーブル拡張モジュール
+#
 module Mdextab
+  #
+  # エラークラス
+  #
   class Error < StandardError; end
 
+  #
+  # MarkDownテーブル拡張モジュールクラス
+  #
   class Mdextab
-    def initialize(opt, fname, o_fname, yamlfname, auxiliaryYamlFname=nil)
+    require "mdextab/version"
+    require "mdextab/token"
+    require "mdextab/table"
+    require "mdextab/tbody"
+    require "mdextab/td"
+    require "mdextab/th"
+    require "mdextab/token"
+    require "mdextab/tr"
+    require "mdextab/makemdtab"
+    require "mdextab/layer"
+    require "messagex/loggerx"
+    require "filex"
+
+    require "byebug"
+
+    #
+    # 初期化
+    # @param [Hash] オプション
+    # @param [String] 入力Markdownファイル名
+    # @param [String] 出力Markdownファイル名
+    # @param [Messagex] mes Messagexクラスのインスタンス
+    def initialize(opt, fname, o_fname, mes=nil)
       @fname = fname
-      @yamlfname = yamlfname
-      @auxiliaryYamlFname = auxiliaryYamlFname
-
-      @envStruct = Struct.new("Env" , :table, :star, :curState)
-      @env = nil
-      @envs = []
-
-      @exit_nil=1
-      @exit_exception=2
-      @exit_next_state=3
-      @exit_unknown=4
-      @exit_table_end=5
-      @exit_cannot_find_file=6
-      @exit_cannot_write_file=7
-      @exit_else=8
-      @exit_illeagal_state=90
-
-      @logger = Loggerx.new("log.txt")
-      #    @logger.level = Logger::WARN
-      #    @logger.level = Logger::INFO
-      @logger.level = Logger::DEBUG if opt["debug"]
-
-      # UNKNOWN > FATAL > ERROR > WARN > INFO > DEBUG
-      #    @logger.datetime_format = '%Y-%m-%d %H:%M:%S'
-      @logger.datetime_format = ''
-      #logger.formatter = proc do |severity, datetime, progname, msg|
-      #   ">>>>>> #{msg}\n"
-      #end
+      @o_fname = o_fname
+
+      @mes = mes
+      unless @mes
+        @mes = Messagex::Messagex.new("EXIT_CODE_NORMAL_EXIT", 0, opt["debug"])
+        @mes.register_ecx
+      end
+
+      @mes.add_exitcode("EXIT_CODE_NEXT_STATE")
+      @mes.add_exitcode("EXIT_CODE_NIL")
+      @mes.add_exitcode("EXIT_CODE_EXCEPTION")
+      @mes.add_exitcode("EXIT_CODE_TABLE_END")
+      @mes.add_exitcode("EXIT_CODE_UNKNOWN")
+      @mes.add_exitcode("EXIT_CODE_ILLEAGAL_STATE")
+
+      Filex::Filex.setup(@mes)
+
       unless File.exist?(fname)
-        mes="Can't find #{fname}"
-        if @logger
-          @logger.error(mes)
-        else
-          STDERR.puts(mes)
-        end
-        exit(@exit_cannot_find_file)
+        @mes.output_fatal("Can't find #{fname}")
+        exit(@mes.ec("EXIT_CODE_CANNOT_FIND_FILE"))
       end
 
-      begin
-        @output = File.open(o_fname, 'w')
-      rescue => ex
-        mes2="Can't write #{o_fname}"
-        if @logger
-          @logger.error(mes2)
-        else
-          STDERR.puts(mes2)
-        end
-        exit(@exit_cannot_write_file)
+      dir = File.dirname(o_fname)
+      if dir != "."
+        @mes.exc_make_directory(dir) { FileUtils.mkdir_p(dir) }
       end
+      @mes.exc_file_write(o_fname) { @output = File.open(o_fname, "w") }
 
-      @fname = fname
-      @state = {
-        START: {TABLE_START: :IN_TABLE , ELSE: :OUT_OF_TABLE, STAR_START: :START, STAR_END: :START},
-        OUT_OF_TABLE: {TABLE_START: :IN_TABLE , ELSE: :OUT_OF_TABLE, STAR_START: :OUT_OF_TABLE, STAR_END: :OUT_OF_TABLE, TD: :OUT_OF_TABLE },
-        IN_TABLE: {TBODY_START: :IN_TABLE_BODY, TABLE_END: :OUT_OF_TABLE, ELSE: :IN_TABLE, TD: :IN_TD_NO_TBODY, TH: :IN_TH_NO_TBODY, TABLE_START: :IN_TABLE, STAR_START: :IN_TABLE, STAR_END: :IN_TABLE},
-        IN_TABLE_BODY: { TH: :IN_TH , TD: :IN_TD , ELSE: :IN_TABLE_BODY, TABLE_START: :IN_TABLE_BODY, TBODY_END: :IN_TABLE, TABLE_END: :OUT_OF_TABLE, STAR_START: :IN_TABLE_BODY, STAR_END: :IN_TABLE_BODY},
-        IN_TH: {ELSE: :IN_TH, TH: :IN_TH, TD: :IN_TD, TABLE_START: :IN_TH, STAR_START: :IN_TH, STAR_END: :IN_TH},
-        IN_TH_NO_TBODY: {ELSE: :IN_TH_NO_TBODY, TH: :IN_TH_NO_TBODY, TD: :IN_TD_NO_TBODY, TABLE_START: :IN_TH_NO_TBODY, STAR_START: :IN_TH_NO_TBODY, STAR_END: :IN_TH_NO_TBODY},
-        IN_TD: {ELSE: :IN_TD, TH: :IN_TH, TD: :IN_TD, TBODY_END: :IN_TABLE, TABLE_START: :IN_TD, STAR_START: :IN_TD, START_END: :IN_TD},
-        IN_TD_NO_TBODY: {ELSE: :IN_TD_NO_TBODY, TH: :IN_TH_NO_TBODY, TD: :IN_TD_NO_TBODY, TABLE_START: :IN_TD_NO_TBODY, TABLE_END: :OUT_OF_TABLE, TBODY_END: :IN_TABLE, STAR_START: :IN_TD_NO_TBODY, STAR_END: :IN_TD_NO_TBODY},
-      }
+      @token_op = Token.new(@mes)
+      @layer = Layer.new(@mes, @output)
 
+      set_state
     end
 
-    def getToken(l, lineno)
-      case l
-      when /^\*S(.+)$/
-        content = $1
-        ret = Token.new(:STAR_START, {content: content, lineno: lineno})
-      when /^\*E(.+)$/
-        content = $1
-        ret = Token.new(:STAR_END, {content: content, lineno: lineno})
-      when /^\s*<table/
-        if /^\s*<table>\s*$/.match?(l)
-          @logger.debug(%Q!T1 :TABLE_START attr: nil!)
-          ret = Token.new(:TABLE_START, {lineno: lineno})
-        elsif (m=/^\s*<table\s+(.+)>\s*$/.match(l))
-          @logger.debug(%Q!T2 :TABLE_START attr: #{m[1]}!)
-          ret = Token.new(:TABLE_START, {attr: m[1], lineno: lineno})
-        else
-          @logger.debug("E002 l=#{l}")
-          ret = nil
-        end
-      when /^\s*<tbody/
-        if /^\s*<tbody>\s*$/.match?(l)
-          ret = Token.new(:TBODY_START, {lineno: lineno})
-        else
-          @logger.debug("E003 l=#{l}")
-          ret = nil
-        end        
-
-      when /^\s*(\:+)(.*)$/
-        nth = $1.size
-        cont = $2
-        if (m=/^th(.*)/.match(cont))
-          cont2 = m[1]
-          @logger.debug( %Q!cont2=#{cont2}! )
-          if (m2=/^\s(.*)/.match(cont2))
-            cont3 = m2[1]
-            if (m3=/^([^<]*)>(.*)$/.match(cont3))
-              attr = m3[1]
-              cont4 = m3[2]
-              @logger.debug( %Q!1 :TH , { nth: #{nth} , attr: #{attr} , content: #{cont4}}! )
-              ret = Token.new(:TH , { nth: nth , attr: attr , content: cont4, lineno: lineno})
-            else
-              # error
-              #ret = nil
-              @logger.debug( %Q!2 :ELSE , { nth: #{nth} , attr: nil , content: #{cont}}! )
-              ret = Token.new(:ELSE , { nth: nth , attr: nil , content: cont, lineno: lineno})
-            end
-          elsif (m=/^>(.*)$/.match(cont2))
-            cont3 = m[1]
-            @logger.debug( %Q!3 :TH , { nth: #{nth} , attr: nil , content: #{cont3}}! )
-            ret = Token.new(:TH , { nth: nth , attr: nil , content: cont3, lineno: lineno})
-          else
-            @logger.debug( %Q!4 :ELSE , { nth: #{nth} , attr: nil , content: #{cont}}! )
-            ret = Token.new(:ELSE , { nth: nth , attr: nil , content: cont, lineno: lineno})
-          end
-        elsif (m=/^([^<]*)>(.*)$/.match(cont))
-          attr = m[1]
-          cont2 = m[2]
-          @logger.debug( %Q!5 :TD , { nth: #{nth} , attr: #{attr} , content: #{cont2}}! )
-          ret = Token.new(:TD , {nth: nth , attr: attr , content: cont2, lineno: lineno})
-        else
-          @logger.debug( %Q!6 :TD , { nth: #{nth} , attr: #{attr} , content: #{cont}}! )
-          ret = Token.new(:TD , { nth: nth , attr: attr , content: cont , lineno: lineno})
-        end
-      when /^\s*<\/table/
-        if /^\s*<\/table>\s*$/.match?(l)
-          ret = Token.new(:TABLE_END, {lineno: lineno})
-        else
-          @logger.debug("E000 l=#{l}")
-          ret = nil
-        end
-      when /^\s*<\/tbody/
-        if /^\s*<\/tbody>\s*$/.match?(l)
-          ret = Token.new(:TBODY_END, {lineno: lineno})
-        else
-          @logger.debug("E001 l=#{l}")
-          ret = nil
-        end
-      else
-        ret = Token.new(:ELSE, {content: l, lineno: lineno})
-      end
-
-      ret
+    #
+    # テーブル拡張向け構文解析用状態遷移テーブルの設定
+    #
+    def set_state
+      @states = {
+        START: { TABLE_START: :IN_TABLE, ELSE: :OUT_OF_TABLE, STAR_START: :START, STAR_END: :START },
+        OUT_OF_TABLE: { TABLE_START: :IN_TABLE, ELSE: :OUT_OF_TABLE, STAR_START: :OUT_OF_TABLE, STAR_END: :OUT_OF_TABLE, TD: :OUT_OF_TABLE },
+        IN_TABLE: { TBODY_START: :IN_TABLE_BODY, TABLE_END: :OUT_OF_TABLE, ELSE: :IN_TABLE, TD: :IN_TD_NO_TBODY, TH: :IN_TH_NO_TBODY, TABLE_START: :IN_TABLE, STAR_START: :IN_TABLE, STAR_END: :IN_TABLE },
+        IN_TABLE_BODY: { TH: :IN_TH, TD: :IN_TD, ELSE: :IN_TABLE_BODY, TABLE_START: :IN_TABLE_BODY, TBODY_END: :IN_TABLE, TABLE_END: :OUT_OF_TABLE, STAR_START: :IN_TABLE_BODY, STAR_END: :IN_TABLE_BODY },
+        IN_TH: { ELSE: :IN_TH, TH: :IN_TH, TD: :IN_TD, TABLE_START: :IN_TH, STAR_START: :IN_TH, STAR_END: :IN_TH },
+        IN_TH_NO_TBODY: { ELSE: :IN_TH_NO_TBODY, TH: :IN_TH_NO_TBODY, TD: :IN_TD_NO_TBODY, TABLE_START: :IN_TH_NO_TBODY, STAR_START: :IN_TH_NO_TBODY, STAR_END: :IN_TH_NO_TBODY },
+        IN_TD: { ELSE: :IN_TD, TH: :IN_TH, TD: :IN_TD, TBODY_END: :IN_TABLE, TABLE_START: :IN_TD, STAR_START: :IN_TD, START_END: :IN_TD },
+        IN_TD_NO_TBODY: { ELSE: :IN_TD_NO_TBODY, TH: :IN_TH_NO_TBODY, TD: :IN_TD_NO_TBODY, TABLE_START: :IN_TD_NO_TBODY, TABLE_END: :OUT_OF_TABLE, TBODY_END: :IN_TABLE, STAR_START: :IN_TD_NO_TBODY, STAR_END: :IN_TD_NO_TBODY },
+      }
     end
 
-    def parse
-      @env = getNewEnv()
-      lineno=0
-      Yamlx.loadSetting(@yamlfname , @auxiliaryYamlFname, @fname).each{ |l|
+    #
+    # テーブル拡張向け構文解析
+    # @param [Hash] eRubyスクリプト向け置換用ハッシュ
+    def parse(hash)
+      lineno = 0
+      @layer.add_layer(@fname, lineno)
+      Filex::Filex.check_and_expand_file_lines(@fname, hash, @mes).each do |line|
         lineno += 1
-        token = getToken(l, lineno)
+        token = @token_op.get_token(line, lineno)
         kind = token.kind
 
-        @logger.debug("kind=#{kind}")
-        @logger.debug(%Q!(source)#{lineno}:#{l}!)
-        if @env.curState == nil
-          @logger.error("(script)#{__LINE__}| @env.curState=nil")
+        @mes.output_debug("layer.size=#{@layer.size}")
+        @mes.output_debug("token.kind=#{kind}")
+        @mes.output_debug(%Q!(source)#{lineno}:#{line}!)
+        if @layer.cur_state.nil?
+          @mes.output_error("(script)#{__LINE__}| @layer.cur_state=nil")
         else
-          @logger.debug("(script)#{__LINE__}| @env.curState=#{@env.curState}")
+          @mes.output_debug("(script)#{__LINE__}| @layer.cur_state=#{@layer.cur_state}")
         end
         #        debug_envs(5, token)
 
-        ret = processOneLine(@env.curState, token, l, lineno)
-        unless ret
-          @logger.error("processOneLine returns nil")
-          exit(@exit_next_state)
+        @layer.cur_state = process_one_line(@layer.cur_state, token, line, lineno)
+        unless @layer.cur_state
+          @mes.output_fatal("process_one_line returns nil")
+          exit(@mes.ec("EXIT_CODE_NEXT_STATE"))
         end
-        @env.curState = ret
 
-        v=@env.curState
-        v="nil" unless v
-        @logger.debug("NEXT kind=#{kind} @env.curState=#{v}")
-        @logger.debug("-----")
-      }
-      checkEnvs
+        @mes.output_debug("NEXT kind=#{kind} @layer.cur_state=#{@layer.cur_state}")
+        @mes.output_debug("-----")
+      end
+      @layer.check_layers(@fname)
     end
 
+    #
+    # テーブル拡張向け構文解析
+    # @param [String] eRubyスクリプト向け置換用データファイル名(YAML形式)
+    def parse2(yamlfname)
+      hs = Filex::Filex.check_and_load_yamlfile(yamlfname, @mes)
+      parse(hs)
+    end
 
-    def getNextState(token, line)
+    #
+    # テーブル拡張向け構文解析での次の状態を得る
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def get_next_state(token, line, lineno)
       kind = token.kind
-      @logger.debug("#{__LINE__}|@env.curState=#{@env.curState} #{@env.curState.class}")
-      tmp = @state[@env.curState]
-      if tmp == nil
-        @logger.error(%Q!kind=#{kind}!)
-        @logger.error("=== tmp == nil")
-        exit(@exit_nil)
+      @mes.output_debug("#{__LINE__}|@layer.cur_state=#{@layer.cur_state} #{@layer.cur_state.class}")
+      state_level1 = @states[@layer.cur_state]
+      if state_level1.nil?
+        @mes.output_error(%Q(token.kind=#{kind} | cur_state=#{@layer.cur_state}))
+        @mes.output_error("=== state_level1 == nil")
+        @mes.output_fatal("Next State is nil")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        exit(@mes.ec("EXIT_CODE_NIL"))
       else
-        @logger.debug("tmp=#{tmp}")
-      end
-      @logger.debug("#{__LINE__}|kind=#{kind}")
-      
-      begin
-        nextState = tmp[kind]
-        @logger.debug("#{__LINE__}|nextState=#{nextState}")
-      rescue
-        @logger.fatal(@env.curState)
-        @logger.fatal(kind)
-        @logger.fatal(nextState)
-        @logger.fatal("+++")
-        exit(@exit_exception)
+        @mes.output_debug("state_level1=#{state_level1}")
       end
-      @logger.debug("#{__LINE__}|nextState=#{nextState}")
-      nextState
-    end
+      @mes.output_debug("#{__LINE__}|kind=#{kind}")
 
-    def debug_envs(n, token)
-      @logger.debug( "***#{n}")
-      @envs.each_with_index{|x,ind|
-        @logger.debug( "@envs[#{ind}]=#{@envs[ind]}")
-      }
-      @logger.debug( "******#{n}")
-      @logger.debug( "getNewEnv 1 token.kind=#{token.kind} @env.curState=#{@env.curState}" )
-    end
-
-    def processNestedTableStart(token, lineno)
-      if @env.table.tbody == nil
-        @env.table.add_tbody(lineno)
+      begin
+        next_state = state_level1[kind]
+        @mes.output_debug("#{__LINE__}|next_state=#{next_state}")
+      rescue StandardError
+        @mes.output_fatal("@layer.cur_state=#{@layer.cur_state}")
+        @mes.output_fatal("kind=#{kind}")
+        @mes.output_fatal("next_state=#{next_state}")
+        exit(@mes.ec("EXIT_CODE_EXCEPTION"))
       end
-      @logger.debug( "B getNewEnv 1 token.kind=#{token.kind} token.opt[:lineno]=#{token.opt[:lineno]} @env.curState=#{@env.curState}" )
-      @env = getNewEnv(:OUT_OF_TABLE)
-      @env.table = Table.new(token.opt[:lineno], @logger, token.opt[:attr])
-      @logger.debug( "getNewEnv 3 token.kind=#{token.kind} @env.curState=#{@env.curState}" )
+      @mes.output_debug("#{__LINE__}|next_state=#{next_state}")
+      next_state
     end
 
-    def processTableEnd(token)
-#byebug
-      prevEnv = peekPrevEnv()
-      if prevEnv
-        tmp_table = @env.table
-
-        @logger.debug( "B getPrevEnv 1 token.kind=#{token.kind} token.opt[:lineno]=#{token.opt[:lineno]} @env.curState=#{@env.curState}" )
-        @logger.debug( "@envs.size=#{@envs.size}")
-        @env = getPrevEnv()
-        @return_from_nested_env = true
-        @logger.debug( "getPrevEnv 1 token.kind=#{token.kind} token.opt[:lineno]=#{token.opt[:lineno]} @env.curState=#{@env.curState}" )
-
-        @logger.debug( "0 - processTableEnd @env.curState=#{@env.curState} @return_from_nested_env=#{@return_from_nested_env}")
-        @logger.debug( tmp_table )
-        case @env.curState
-        when :IN_TD
-          @env.table.tdAppend(tmp_table, @env.star)
-        when :IN_TD_NO_TBODY
-          @env.table.tdAppend(tmp_table, @env.star)
-        when :IN_TH
-          @env.table.thAppend(tmp_table, @env.star)
-        when :IN_TH_NO_TBODY
-          @env.table.thAppend(tmp_table,@env.star)
-        when :IN_TABLE
-          if @env.table == nil
-            @logger.fatal( "In processNestedTableEnv: @env.table=nil token.kind=#{token.kind} token.opt[:lineno]=#{token.opt[:lineno]} @env.curState=#{@env.curState}" )
-            raise
-          end
-          @env.table.add(tmp_table)
-        when :IN_TABLE_BODY
-          @env.table.add(tmp_table)
-        when :START
-          # do nothing?
+    #
+    # トークンELSEに対応する行の出力
+    # @param [String] str トークンELSEに対応する行
+    def output_in_else(str)
+      if @layer.star
+        if str.match?(/^\s*$/)
+          @mes.output_debug("InElse do nothing")
         else
-          v = @env.curState
-          v = "nil" unless v
-          @logger.error("E100 @env.curState=#{v}")
-          @logger.error("@env.table=#{@env.table}")
-          exit(@exit_table_end)
+          @mes.exc_file_write(@o_fname) { @output.puts(str) }
         end
       else
-        @logger.debug( "1 - processTableEnd @env.curState=#{@env.curState} @return_from_nested_env~#{@return_from_nested_env}")
-        @output.puts(@env.table.end)
+        @mes.exc_file_write(@o_fname) { @output.puts(str) }
       end
     end
 
-    def outputInElse(str)
-      if @env.star
+    #
+    # テーブルのTHタグの一部として、トークンELSEに対応する行を追加
+    # @param [String] str トークンELSEに対応する行
+    def table_th_append_in_else(str)
+      if @layer.star
         if str.match?(/^\s*$/)
-          @logger.debug("InElse do nothing")
+          @mes.output_debug("ThAppend InElse")
         else
-          @output.puts(str)
+          @layer.table.th_append(str, @layer.star)
         end
       else
-        @output.puts(str)
-      end        
+        @layer.table.th_append(str, @layer.star)
+      end
     end
 
-    def tableThAppendInElse(str)
-      if @env.star
+    #
+    # テーブルのTDタグの一部として、トークンELSEに対応する行を追加
+    # @param [String] str トークンELSEに対応する行
+    def table_td_append_in_else(str)
+      if @layer.star
         if str.match?(/^\s*$/)
-          @logger.debug("ThAppend InElse")
+          @mes.output_debug("TdAppend InElse")
         else
-          @env.table.thAppend(str,@env.star)
+          @layer.table.td_append(str, @layer.star)
         end
       else
-        @env.table.thAppend(str,@env.star)
-      end        
+        @layer.table.td_append(str, @layer.star)
+      end
     end
 
-    def tableTdAppendInElse(str)
-      if @env.star
-        if str.match?(/^\s*$/)
-          @logger.debug("TdAppend InElse")
-        else
-          @env.table.tdAppend(str,@env.star)
-        end
+    #
+    # START状態でのトークンと現在行の処理
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def process_one_line_for_start(token, line, lineno)
+      case token.kind
+      when :TABLE_START
+        @layer.table = Table.new(lineno, @mes, token.opt[:attr])
+      when :ELSE
+        # threw
+        output_in_else(token.opt[:content])
+      when :STAR_START
+        @layer.star = true
+        output_in_else("*" + token.opt[:content])
+      when :STAR_END
+        @layer.star = false
+        output_in_else("*" + token.opt[:content])
+        output_in_else(token.opt[:content])
       else
-        @env.table.tdAppend(str,@env.star)
-      end        
+        @mes.output_fatal("In :START unknown tag=(#{token.kind}) in process_one_line_for_start")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        exit(@mes.ec("EXIT_CODE_UNKNOWN"))
+      end
     end
 
-    def processOneLine(curState, token, line, lineno)
-      @return_from_nested_env = false
-      case @env.curState
-      when :START
-        case token.kind
-        when :TABLE_START
-          @env.table = Table.new(lineno, @logger,token.opt[:attr])
-        when :ELSE
-          # threw
-          outputInElse(token.opt[:content])
-        when :STAR_START
-          @env.star = true
-          outputInElse('*'+token.opt[:content])
-        when :STAR_END
-          @env.star = false       
-          outputInElse('*'+token.opt[:content])
-          outputInElse(token.opt[:content])
-        else
-          @logger.error( ":START [unknown]")
-          exit(@exit_unknown)
-        end
-      when :OUT_OF_TABLE
-        case token.kind
-        when :TABLE_START
-          @env.table = Table.new(lineno, @logger,token.opt[:attr])
-        when :ELSE
-          outputInElse(token.opt[:content])
-        when :STAR_START
-          @env.star = true
-          outputInElse('*'+token.opt[:content])
-        when :STAR_END
-          @env.star = false       
-          outputInElse('*'+token.opt[:content])
-          outputInElse(token.opt[:content])
-        when :TD
-          # treat as :ELSE
-          outputInElse(":" + token.opt[:content])
-        else
-          @logger.error( ":OUT_OF_TABLE [unknown]")
-          exit(@exit_unknown)
-        end
-      when :IN_TABLE
-        case token.kind
-        when :TBODY_START
-          @env.table.add_tbody(lineno)
-        when :TABLE_END
-          processTableEnd(token)
-        when :ELSE
-          outputInElse(token.opt[:content])
-        when :TD
-          @logger.debug(token)
-          @env.table.add_tbody(lineno)
-          @env.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TH
-          @env.table.add_tbody(lineno)
-          @env.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TABLE_START
-          processNestedTableStart(token, lineno)
-        when :STAR_START
-          @env.star = true
-          outputInElse('*'+token.opt[:content])
-        when :STAR_END
-          @env.star = false
-          outputInElse('*'+token.opt[:content])
-        else
-          @logger.error( ":IN_TABLE [unknown]")
-          exit(@exit_unknown)
-        end
-      when :IN_TABLE_BODY
-        case token.kind
-        when :TH
-          @env.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TD
-          @logger.debug(token)
-          @env.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :ELSE
-          outputInElse(token.opt[:content])
-        when :TABLE_START
-          processNestedTableStart(token, lineno)
-        when :TBODY_END
-          #  processTableEnd(token)
-        when :TABLE_END
-          processTableEnd(token)
-        when :STAR_START
-          @env.star = true
-          outputInElse('*'+token.opt[:content])
-        when :STAR_END
-          @env.star = false       
-          outputInElse('*'+token.opt[:content])
-        else
-          @logger.error( ":IN_TABLE_BODY [unknown]")
-          exit(@exit_unknown)
-          #
-        end
-      when :IN_TH
-        case token.kind
-        when :ELSE
-          tableThAppendInElse(token.opt[:content])
-        when :TH
-          @env.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TD
-          @env.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TABLE_START
-          processNestedTableStart(token, lineno)
-=begin
-          #        debug_envs(3, token)
-          @env = getNewEnv(:OUT_OF_TABLE)
-          @env.table = Table.new(lineno, @logger,token.opt[:attr])
-          @logger.debug( "getNewEnv 2 token.kind=#{token.kind} @env.curState=#{@env.curState}" )
-          #        debug_envs(4, token)
-=end
-        when :STAR_START
-          @env.star = true
-          tableThAppendInElse('*'+token.opt[:content])
-        when :STAR_END
-          @env.star = false       
-          tableThAppendInElse('*'+token.opt[:content])
-        else
-          @logger.error( ":IN_TH [unknown]")
-          exit(@exit_unknown)
-          #
-        end
-      when :IN_TH_NO_TBODY
-        case token.kind
-        when :ELSE
-          tableThAppendInElse(token.opt[:content])
-        when :TH
-          @env.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TD
-          @env.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TABLE_START
-          processNestedTableStart(token, lineno)
-=begin
-          #        debug_envs(3, token)
-          @env = getNewEnv(:OUT_OF_TABLE)
-          @env.table = Table.new(lineno, @logger,token.opt[:attr])
-          @logger.debug( "getNewEnv 2 token.kind=#{token.kind} @env.curState=#{@env.curState}" )
-          #        debug_envs(4, token)
-=end
-        when :STAR_START
-          @env.star = true
-          tableThAppendInElse('*'+token.opt[:content])
-        when :STAR_END
-          @env.star = false       
-          tableThAppendInElse('*'+token.opt[:content])
-        else
-          @logger.error( ":IN_TH_NO_TBODY [unknown]")
-          exit(@exit_unknown)
-          #
-        end
-      when :IN_TD
-        case token.kind
-        when :ELSE
-          tableTdAppendInElse(token.opt[:content])
-        when :TH
-          @env.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TD
-          @env.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TBODY_END
-          @env.table.tbody_end()
-        when :TABLE_START
-          processNestedTableStart(token, lineno)
-        when :STAR_START
-          @env.star = true
-          tableTdAppendInElse('*'+token.opt[:content])
-        when :STAR_END
-          @env.star = false       
-          tableTdAppendInElse('*'+token.opt[:content])
-        else
-          @logger.error( ":IN_TD [unknown]")
-          exit(@exit_unknown)
-          #
-        end
-      when :IN_TD_NO_TBODY
-        case token.kind
-        when :ELSE
-          tableTdAppendInElse(token.opt[:content])
-        when :TH
-          @env.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TD
-          @env.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr],@env.star)
-        when :TABLE_START
-          processNestedTableStart(token, lineno)
-        when :TABLE_END
-          processTableEnd(token)
-        when :TBODY_END
-          @env.table.tbody_end()
-        when :STAR_START
-          @env.star = true
-          tableTdAppendInElse('*'+token.opt[:content])
-        when :STAR_END
-          @env.star = false       
-          tableTdAppendInElse('*'+token.opt[:content])
-        else
-          @logger.error( ":IN_TD_NO_TBODY [unknown]")
-          exit(@exit_unknown)
-          #
-        end
+    #
+    # OUT_OF_TABLE状態でのトークンと現在行の処理
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def process_one_line_for_out_of_table(token, line, lineno)
+      case token.kind
+      when :TABLE_START
+        @layer.table = Table.new(lineno, @mes, token.opt[:attr])
+      when :ELSE
+        output_in_else(token.opt[:content])
+      when :STAR_START
+        @layer.star = true
+        output_in_else("*" + token.opt[:content])
+      when :STAR_END
+        @layer.star = false
+        output_in_else("*" + token.opt[:content])
+        output_in_else(token.opt[:content])
+      when :TD
+        # treat as :ELSE
+        output_in_else(":" + token.opt[:content])
       else
-        @logger.error( "unknown state")
-        exit(@exit_unknown)
-        #
+        @mes.output_fatal("In :OUT_OF_TABLE unknown tag=(#{token.kind}) in process_one_line_for_out_of_table")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        @layer.check_layers(@fname)
       end
+    end
+
+    #
+    # TABLE_END状態でのトークン処理
+    # @param [String] token 読み込んだトークン
+    def process_one_line_for_table_end(token)
+      @layer.process_table_end(token)
+      return if @layer.return_from_nested_env
 
-      unless @return_from_nested_env
-        nextState = getNextState(token, line)
-        @logger.debug("#{__LINE__}|nextState=#{nextState}")
+      @mes.output_debug("1 - process_one_line_table_end cur_state=#{@layer.cur_state} @return_from_nested_env~#{@layer.return_from_nested_env}")
+      @mes.exc_file_write(@o_fname) { @output.puts(@layer.table.end) }
+    end
+
+    #
+    # IN_TABLE状態でのトークンと現在行の処理
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def process_one_line_for_in_table(token, line, lineno)
+      case token.kind
+      when :TBODY_START
+        @layer.table.add_tbody(lineno)
+      when :TABLE_END
+        process_one_line_for_table_end(token)
+      when :ELSE
+        output_in_else(token.opt[:content])
+      when :TD
+        @mes.output_debug(token)
+        @layer.table.add_tbody(lineno)
+        @layer.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TH
+        @layer.table.add_tbody(lineno)
+        @layer.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TABLE_START
+        @layer.process_nested_table_start(token, lineno)
+      when :STAR_START
+        @layer.star = true
+        output_in_else("*" + token.opt[:content])
+      when :STAR_END
+        @layer.star = false
+        output_in_else("*" + token.opt[:content])
       else
-        nextState = @env.curState
+        @mes.output_fatal("In :IN_TABLE unknown tag=(#{token.kind}) in process_one_line_for_in_table")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        exit(@mes.ec("EXIT_CODE_UNKNOWN"))
       end
-      nextState
     end
 
-    def end
-      @output.close
+    #
+    # IN_TABLE_BODY状態でのトークンと現在行の処理
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def process_one_line_for_in_table_body(token, line, lineno)
+      case token.kind
+      when :TH
+        @layer.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TD
+        @mes.output_debug(token)
+        @layer.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :ELSE
+        output_in_else(token.opt[:content])
+      when :TABLE_START
+        @layer.process_nested_table_start(token, lineno)
+      when :TBODY_END
+        true #  don't call process_table_end(token)
+      when :TABLE_END
+        process_one_line_for_table_end(token)
+      when :STAR_START
+        @layer.star = true
+        output_in_else("*" + token.opt[:content])
+      when :STAR_END
+        @layer.star = false
+        output_in_else("*" + token.opt[:content])
+      else
+        @mes.output_fatal("In :IN_TABLE_BODY unknown tag=(#{token.kind}) in process_one_line_for_in_table_body")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        exit(@mes.ec("EXIT_CODE_UNKNOWN"))
+      end
     end
 
-    def getNewEnv(state=:START)
-      new_env = @envStruct.new
-      @envs << new_env
-      new_env.curState = state
-      if @env
-        new_env.star = @env.star
+    #
+    # IN_TH状態でのトークンと現在行の処理
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def process_one_line_for_in_th(token, line, lineno)
+      case token.kind
+      when :ELSE
+        table_th_append_in_else(token.opt[:content])
+      when :TH
+        @layer.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TD
+        @layer.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TABLE_START
+        @layer.process_nested_table_start(token, lineno)
+      when :STAR_START
+        @layer.star = true
+        table_th_append_in_else("*" + token.opt[:content])
+      when :STAR_END
+        @layer.star = false
+        table_th_append_in_else("*" + token.opt[:content])
       else
-        new_env.star = false
+        @mes.output_fatal("In :IN_TH unknown tag=(#{token.kind}) in process_one_line_for_in_th")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        exit(@mes.ec("EXIT_CODE_UNKNOWN"))
       end
-      new_env
     end
 
-    def getCurState
-      ret = @env.curState
+    #
+    # IN_TH_NO_TBODY状態でのトークンと現在行の処理
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def process_one_line_for_in_th_no_tbody(token, line, lineno)
+      case token.kind
+      when :ELSE
+        table_th_append_in_else(token.opt[:content])
+      when :TH
+        @layer.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TD
+        @layer.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TABLE_START
+        @layer.process_nested_table_start(token, lineno)
+      when :STAR_START
+        @layer.star = true
+        table_th_append_in_else("*" + token.opt[:content])
+      when :STAR_END
+        @layer.star = false
+        table_th_append_in_else("*" + token.opt[:content])
+      else
+        @mes.output_fatal("In :IN_TH_NO_TBODY unknown tag=(#{token.kind}) in process_one_line_for_in_th_no_tbody")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        exit(@mes.ec("EXIT_CODE_UNKNOWN"))
+      end
     end
 
-    def getPrevEnv()
-      @envs.pop
-      @envs.last
+    #
+    # IN_TD状態でのトークンと現在行の処理
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def process_one_line_for_in_td(token, line, lineno)
+      case token.kind
+      when :ELSE
+        table_td_append_in_else(token.opt[:content])
+      when :TH
+        @layer.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TD
+        @layer.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TBODY_END
+        @layer.table.tbody_end
+      when :TABLE_START
+        @layer.process_nested_table_start(token, lineno)
+      when :STAR_START
+        @layer.star = true
+        table_td_append_in_else("*" + token.opt[:content])
+      when :STAR_END
+        @layer.star = false
+        table_td_append_in_else("*" + token.opt[:content])
+      else
+        @mes.output_fatal("In :IN_TD unknown tag=(#{token.kind}) in process_one_line_for_in_td")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        exit(@mes.ec("EXIT_CODE_UNKNOWN"))
+      end
     end
 
-    def peekPrevEnv()
-      if @envs.size > 1
-        @envs[@envs.size-2]
+    #
+    # IN_TD_NO_TBODY状態でのトークンと現在行の処理
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def process_one_line_for_in_td_no_tbody(token, line, lineno)
+      case token.kind
+      when :ELSE
+        table_td_append_in_else(token.opt[:content])
+      when :TH
+        @layer.table.add_th(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TD
+        @layer.table.add_td(lineno, token.opt[:content], token.opt[:nth], token.opt[:attr], @layer.star)
+      when :TABLE_START
+        @layer.process_nested_table_start(token, lineno)
+      when :TABLE_END
+        process_one_line_for_table_end(token)
+      when :TBODY_END
+        @layer.table.tbody_end
+      when :STAR_START
+        @layer.star = true
+        table_td_append_in_else("*" + token.opt[:content])
+      when :STAR_END
+        @layer.star = false
+        table_td_append_in_else("*" + token.opt[:content])
       else
-        nil
+        @mes.output_fatal("In :IN_TD_NO_TBODY unknown tag=(#{token.kind}) in process_one_line_for_in_td_no_tbody")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        exit(@mes.ec("EXIT_CODE_UNKNOWN"))
       end
     end
 
-    def checkEnvs
-      case @env.curState
-      when :OUT_OF_TABLE
-        if @envs.size > 1
-          @logger.info("illeagal nested env after parsing|:OUT_OF_TABLE")
-          @logger.fatal("@envs.size=#{@envs.size} :TABLE_START #{@env.table.lineno}" )
-          @envs.map{ |x| 
-            @logger.fatal("== @envs.curState=#{x.curState} :TABLE_START #{x.table.lineno}") 
-          }
-          @logger.fatal("== @env.table")
-          @logger.info(@env.table)
-          raise
-        end
+    #
+    # 現在の状態に対するトークンと現在行の処理
+    # @param [Symbol] current_state 現在の状態
+    # @param [String] token 読み込んだトークン
+    # @param [String] line 現在行
+    # @param [String] lineno 現在行の行番号
+    def process_one_line(current_state, token, line, lineno)
+      @layer.return_from_nested_env = false
+
+      case current_state
       when :START
-        if @envs.size > 1
-          @logger.fatal("illeagal nested env after parsing|:START")
-          @logger.fatal("@envs.size=#{@envs.size}")
-          @envs.map{ |x| 
-            @logger.fatal("== @envs.curState=#{x.curState} :TABLE_START #{x.table.lineno}") 
-          }
-          @logger.fatal("== @env.table")
-          @logger.fatal(@env.table)
-          raise
-        end
+        process_one_line_for_start(token, line, lineno)
+      when :OUT_OF_TABLE
+        process_one_line_for_out_of_table(token, line, lineno)
+      when :IN_TABLE
+        process_one_line_for_in_table(token, line, lineno)
+      when :IN_TABLE_BODY
+        process_one_line_for_in_table_body(token, line, lineno)
+      when :IN_TH
+        process_one_line_for_in_th(token, line, lineno)
+      when :IN_TH_NO_TBODY
+        process_one_line_for_in_th_no_tbody(token, line, lineno)
+      when :IN_TD
+        process_one_line_for_in_td(token, line, lineno)
+      when :IN_TD_NO_TBODY
+        process_one_line_for_in_td_no_tbody(token, line, lineno)
       else
-        @logger.fatal("illeagal state after parsing(#{@env.curState}|#{@env.curState.class})")
-        @logger.fatal("@envs.size=#{@envs.size}")
-        @logger.fatal("== @env.curState=#{@env.curState}")
-        @envs.map{ |x| 
-          @logger.fatal("== @envs.curState=#{x.curState} #{@fname}:#{x.table.lineno}") 
-        }
-#        @logger.fatal("== @env.table")
-#        @logger.fatal(@env.table)
-#        raise
-        @logger.fatal("")
-        exit(@exit_illeagal_state)
+        @mes.output_fatal("In Unknown state(#{current_state}) in process_one_line")
+        @mes.output_fatal("@fname=#{@fname} | lineno=#{lineno}")
+        exit(@mes.ec("EXIT_CODE_UNKNOWN"))
+      end
+
+      if @layer.return_from_nested_env
+        next_state = @layer.cur_state
+      else
+        next_state = get_next_state(token, line, lineno, @fname)
+
+        @mes.output_debug("#{__LINE__}|next_state=#{next_state}")
       end
+      next_state
     end
   end
 end