lingo 1.8.0 → 1.8.1

data/lib/lingo/attendee/synonymer.rb

@@ -1,103 +1,100 @@
 # encoding: utf-8
 
 #--
-# LINGO ist ein Indexierungssystem mit Grundformreduktion, Kompositumzerlegung,
-# Mehrworterkennung und Relationierung.
-#
-# Copyright (C) 2005-2007 John Vorhauer
-# Copyright (C) 2007-2011 John Vorhauer, Jens Wille
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU Affero General Public License as published by the Free
-# Software Foundation; either version 3 of the License, or (at your option)
-# any later version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
-#
-# For more information visit http://www.lex-lingo.de or contact me at
-# welcomeATlex-lingoDOTde near 50°55'N+6°55'E.
-#
-# Lex Lingo rules from here on
+###############################################################################
+#                                                                             #
+# Lingo -- A full-featured automatic indexing system                          #
+#                                                                             #
+# Copyright (C) 2005-2007 John Vorhauer                                       #
+# Copyright (C) 2007-2012 John Vorhauer, Jens Wille                           #
+#                                                                             #
+# Lingo is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# Lingo is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with Lingo. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
 #++
 
 class Lingo
 
-  # Der Synonymer untersucht die von anderen Attendees ermittelten Grundformen eines Wortes
-  # und sucht in den angegebenen Wörterbüchern nach Relationen zu anderen Grundformen.
-  # Gefundene Relationen erweitern die Liste des Word-Objektes und werden zur späteren
-  # Identifizierung mit der Wortklasse 'y' gekennzeichnet.
-  #
-  # === Mögliche Verlinkung
-  # Erwartet:: Daten vom Typ *Word* z.B. von Wordsearcher, Decomposer, Ocr_variator, Multiworder
-  # Erzeugt:: Daten vom Typ *Word* (ggf. um Relationen ergänzt) z.B. für Decomposer, Ocr_variator, Multiworder, Sequencer, Noneword_filter, Vector_filter
-  #
-  # === Parameter
-  # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
-  # Alle anderen Parameter müssen zwingend angegeben werden.
-  # <b>in</b>:: siehe allgemeine Beschreibung des Attendee
-  # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
-  # <b>source</b>:: siehe allgemeine Beschreibung des Dictionary
-  # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
-  # <b><i>skip</i></b>:: (Standard: WA_UNKNOWN [siehe strings.rb]) Veranlasst den Synonymer
-  #                      Wörter mit diesem Attribut zu überspringen.
-  #
-  # === Beispiele
-  # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
-  #   meeting:
-  #     attendees:
-  #       - textreader:   { out: lines, files: '$(files)' }
-  #       - tokenizer:    { in: lines, out: token }
-  #       - abbreviator:  { in: token, out: abbrev, source: 'sys-abk' }
-  #       - wordsearcher: { in: abbrev, out: words, source: 'sys-dic' }
-  #       - synonymer:    { in: words, out: synos, source: 'sys-syn' }
-  #       - debugger:     { in: words, prompt: 'out>' }
-  # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
-  #   out> *FILE('test.txt')
-  #   out> <Dies = [(dies/w), (das/y), (dies/y)]>
-  #   out> <ist = [(sein/v), ((sich) befinden/y), (dasein/y), (existenz/y), (sein/y), (vorhandensein/y)]>
-  #   out> <ggf. = [(gegebenenfalls/w), (bei bedarf/y), (gegebenenfalls/y), (ggf./y), (notfalls/y)]>
-  #   out> <eine = [(einen/v), (ein/w)]>
-  #   out> <Abk³rzung = [(abk³rzung/s), (abbreviation/y), (abbreviatur/y), (abk³rzung/y), (akronym/y), (kurzbezeichnung/y)]>
-  #   out> :./PUNC:
-  #   out> *EOL('test.txt')
-  #   out> *EOF('test.txt')
+  class Attendee
 
-  class Attendee::Synonymer < Attendee
+    # Der Synonymer untersucht die von anderen Attendees ermittelten Grundformen eines Wortes
+    # und sucht in den angegebenen Wörterbüchern nach Relationen zu anderen Grundformen.
+    # Gefundene Relationen erweitern die Liste des Word-Objektes und werden zur späteren
+    # Identifizierung mit der Wortklasse 'y' gekennzeichnet.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten vom Typ *Word* z.B. von Wordsearcher, Decomposer, Ocr_variator, Multiworder
+    # Erzeugt:: Daten vom Typ *Word* (ggf. um Relationen ergänzt) z.B. für Decomposer, Ocr_variator, Multiworder, Sequencer, Noneword_filter, Vector_filter
+    #
+    # === Parameter
+    # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
+    # Alle anderen Parameter müssen zwingend angegeben werden.
+    # <b>in</b>:: siehe allgemeine Beschreibung des Attendee
+    # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
+    # <b>source</b>:: siehe allgemeine Beschreibung des Dictionary
+    # <b><i>mode</i></b>:: (Standard: all) siehe allgemeine Beschreibung des Dictionary
+    # <b><i>skip</i></b>:: (Standard: WA_UNKNOWN [siehe strings.rb]) Veranlasst den Synonymer
+    #                      Wörter mit diesem Attribut zu überspringen.
+    #
+    # === Beispiele
+    # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+    #   meeting:
+    #     attendees:
+    #       - text_reader:   { out: lines, files: '$(files)' }
+    #       - tokenizer:     { in: lines, out: token }
+    #       - abbreviator:   { in: token, out: abbrev, source: 'sys-abk' }
+    #       - word_searcher: { in: abbrev, out: words, source: 'sys-dic' }
+    #       - synonymer:     { in: words, out: synos, source: 'sys-syn' }
+    #       - debugger:      { in: words, prompt: 'out>' }
+    # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+    #   out> *FILE('test.txt')
+    #   out> <Dies = [(dies/w), (das/y), (dies/y)]>
+    #   out> <ist = [(sein/v), ((sich) befinden/y), (dasein/y), (existenz/y), (sein/y), (vorhandensein/y)]>
+    #   out> <ggf. = [(gegebenenfalls/w), (bei bedarf/y), (gegebenenfalls/y), (ggf./y), (notfalls/y)]>
+    #   out> <eine = [(einen/v), (ein/w)]>
+    #   out> <Abk³rzung = [(abk³rzung/s), (abbreviation/y), (abbreviatur/y), (abk³rzung/y), (akronym/y), (kurzbezeichnung/y)]>
+    #   out> :./PUNC:
+    #   out> *EOL('test.txt')
+    #   out> *EOF('test.txt')
 
-    protected
+    class Synonymer < self
 
-    def init
-      # Wörterbuch bereitstellen
-      src = get_array('source')
-      mod = get_key('mode', 'all')
-      @dic = Dictionary.new({'source'=>src, 'mode'=>mod}, @lingo)
+      protected
 
-      @skip = get_array('skip', WA_UNKNOWN).collect {|s| s.upcase }
-    end
+      def init
+        set_dic
+        @skip = get_array('skip', WA_UNKNOWN).map(&:upcase)
+      end
 
-    def control(cmd, par)
-      @dic.report.each_pair { |k, v| set( k, v ) } if cmd == STR_CMD_STATUS
-    end
+      def control(cmd, par)
+        @dic.report.each_pair { |k, v| set( k, v ) } if cmd == STR_CMD_STATUS
+      end
 
-    def process(obj)
-      if obj.is_a?(Word) && @skip.index(obj.attr).nil?
-        inc('Anzahl gesuchter Wörter')
+      def process(obj)
+        if obj.is_a?(Word) && @skip.index(obj.attr).nil?
+          inc('Anzahl gesuchter Wörter')
 
-        # finde die Synonyme für alle Lexicals des Wortes
-        synos = @dic.find_synonyms(obj)
-        obj.lexicals += synos.sort.uniq
+          # finde die Synonyme für alle Lexicals des Wortes
+          synos = @dic.find_synonyms(obj)
+          obj.lexicals += synos.sort.uniq
 
-        inc('Anzahl erweiteter Wörter') if synos.size>0
-        add('Anzahl gefundener Synonyme', synos.size)
+          inc('Anzahl erweiteter Wörter') if synos.size>0
+          add('Anzahl gefundener Synonyme', synos.size)
+        end
+        forward(obj)
       end
-      forward(obj)
+
     end
 
   end

data/lib/lingo/attendee/text_reader.rb

@@ -0,0 +1,242 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# Lingo -- A full-featured automatic indexing system                          #
+#                                                                             #
+# Copyright (C) 2005-2007 John Vorhauer                                       #
+# Copyright (C) 2007-2012 John Vorhauer, Jens Wille                           #
+#                                                                             #
+# Lingo is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# Lingo is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with Lingo. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+%w[filemagic mime/types hpricot pdf-reader].each { |lib|
+  begin
+    require lib
+  rescue LoadError
+  end
+}
+
+class Lingo
+
+  class Attendee
+
+    # Der TextReader ist eine klassische Datenquelle. Er liest eine oder mehrere Dateien
+    # und gibt sie Zeilenweise in den Ausgabekanal. Der Start bzw. Wechsel einer Datei
+    # wird dabei über den Kommandokanal angekündigt, ebenso wie das Ende.
+    #
+    # Der TextReader kann ebenfalls ein spezielles Dateiformat verarbeiten, welches zum
+    # Austausch mit dem LIR-System dient. Dabei enthält die Datei Record-basierte Informationen,
+    # die wie mehrere Dateien verarbeitet werden.
+    #
+    # === Mögliche Verlinkung
+    # Erzeugt:: Daten des Typs *String* (Textzeile) z.B. für Tokenizer, Textwriter
+    #
+    # === Parameter
+    # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
+    # Alle anderen Parameter müssen zwingend angegeben werden.
+    # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
+    # <b>files</b>:: Es können eine oder mehrere Dateien angegeben werden, die nacheinander
+    #                eingelesen und zeilenweise weitergeleitet werden. Die Dateien werden mit
+    #                Komma voneinander getrennt, z.B.
+    #                  files: 'readme.txt'
+    #                  files: 'readme.txt,lingo.cfg'
+    # <b><i>lir-record-pattern</i></b>:: Mit diesem Parameter wird angegeben, woran der Anfang
+    #                                    eines neuen Records erkannt werden kann und wie die
+    #                                    Record-Nummer identifiziert wird. Das Format einer
+    #                                    LIR-Datei ist z.B.
+    #                                      [00001.]
+    #                                      020: ¬Die Aufgabenteilung zwischen Wortschatz und Grammatik.
+    #
+    #                                      [00002.]
+    #                                      020: Nicht-konventionelle Thesaurusrelationen als Orientierungshilfen.
+    #                                    Mit der Angabe von
+    #                                      lir-record-pattern: "^\[(\d+)\.\]"
+    #                                    werden die Record-Zeilen erkannt und jeweils die Record-Nummer +00001+,
+    #                                    bzw. +00002+ erkannt.
+    #
+    # === Generierte Kommandos
+    # Damit der nachfolgende Datenstrom einwandfrei verarbeitet werden kann, generiert der TextReader
+    # Kommandos, die mit in den Datenstrom eingefügt werden.
+    # <b>*FILE(<dateiname>)</b>:: Kennzeichnet den Beginn der Datei <dateiname>
+    # <b>*EOF(<dateiname>)</b>:: Kennzeichnet das Ende der Datei <dateiname>
+    # <b>*LIR_FORMAT('')</b>:: Kennzeichnet die Verarbeitung einer Datei im LIR-Format (nur bei LIR-Format).
+    # <b>*RECORD(<nummer>)</b>:: Kennzeichnet den Beginn eines neuen Records (nur bei LIR-Format).
+    # === Beispiele
+    # Bei der Verarbeitung einer normalen Textdatei mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+    #   meeting:
+    #     attendees:
+    #       - text_reader: { out: lines, files: '$(files)' }
+    #       - debugger:    { in: lines, prompt: 'out>' }
+    # ergibt die Ausgabe über den Debugger: <tt>lingo -c t1 test.txt</tt>
+    #   out> *FILE('test.txt')
+    #   out> "Dies ist eine Zeile."
+    #   out> "Dies ist noch eine."
+    #   out> *EOF('test.txt')
+    # Bei der Verarbeitung einer LIR-Datei mit der Ablaufkonfiguration <tt>t2.cfg</tt>
+    #   meeting:
+    #     attendees:
+    #       - text_reader: { out: lines,  files: '$(files)', lir-record-pattern: "^\[(\d+)\.\]" }
+    #       - debugger:    { in: lines, prompt: 'out>'}
+    # ergibt die Ausgabe mit <tt>lingo -c t2 lir.txt</tt>
+    #   out> *LIR-FORMAT('')
+    #   out> *FILE('lir.txt')
+    #   out> *RECORD('00001')
+    #   out> "020: \254Die Aufgabenteilung zwischen Wortschatz und Grammatik."
+    #   out> *RECORD('00002')
+    #   out> "020: Nicht-konventionelle Thesaurusrelationen als Orientierungshilfen."
+    #   out> *EOF('lir.txt')
+
+    class TextReader < self
+
+      protected
+
+      # TODO: FILE und LIR-FILE
+      # TODO: lir-record-pattern abkürzen
+      # Interpretation der Parameter
+      def init
+        @files = Array(get_key('files', '-'))
+        @rec_pat = Regexp.new(get_key('lir-record-pattern', ''))
+        @is_LIR_file = has_key?('lir-record-pattern')
+        @chomp = get_key('chomp', true)
+        @filter = get_key('filter', false)
+      end
+
+      def control(cmd, param)
+        if cmd==STR_CMD_TALK
+          forward(STR_CMD_LIR, '') if @is_LIR_file
+          @files.each { |filename| spool(filename) }
+        end
+      end
+
+      private
+
+      # Gibt eine Datei zeilenweise in den Ausgabekanal
+      def spool(filename)
+        unless stdin?(filename)
+          raise FileNotFoundError.new(filename) unless File.exist?(filename)
+
+          inc('Anzahl Dateien')
+          add('Anzahl Bytes', File.stat(filename).size)
+        end
+
+        forward(STR_CMD_FILE, filename)
+
+        filter(filename) { |line|
+          inc('Anzahl Zeilen')
+          line.chomp! if @chomp
+          line.gsub!(/\303\237/, "ß")
+      ### HACK
+          if @is_LIR_file && line =~ @rec_pat
+            forward(STR_CMD_RECORD, $1)
+          else
+            forward(line) if line.size>0
+          end
+        }
+
+        forward(STR_CMD_EOF, filename)
+      end
+
+      def filter(filename, &block)
+        file = stdin?(filename) ?
+          @lingo.config.stdin.set_encoding(ENC) :
+          File.open(filename, 'rb', encoding: ENC)
+
+        file = case @filter == true ? file_type(filename, file) : @filter.to_s
+          when /html/ then filter_html(file)
+          when /xml/  then filter_html(file, true)
+          when /pdf/  then filter_pdf(file, &block) or return
+          else file
+        end if @filter
+
+        file.each_line(&block)
+      end
+
+      def filter_pdf(file, &block)
+        if Object.const_defined?(:PDF) && PDF.const_defined?(:Reader)
+          PDFFilter.filter(file, &block)
+          nil
+        else
+          warn "PDF filter not available. Please install `pdf-reader'."
+          file
+        end
+      end
+
+      def filter_html(file, xml = false)
+        if Object.const_defined?(:Hpricot)
+          Hpricot(file, xml: xml).inner_text
+        else
+          warn "#{xml ? 'X' : 'HT'}ML filter not available. Please install `hpricot'."
+          file
+        end
+      end
+
+      def file_type(filename, file)
+        if Object.const_defined?(:FileMagic) && file.respond_to?(:rewind)
+          type = FileMagic.fm(:mime, simplified: true).buffer(file.read(256))
+          file.rewind
+          type
+        elsif Object.const_defined?(:MIME) && MIME.const_defined?(:Types)
+          if type = MIME::Types.of(filename).first
+            type.content_type
+          else
+            warn 'Filters not available. File type could not be determined.'
+            nil
+          end
+        else
+          warn "Filters not available. Please install `ruby-filemagic' or `mime-types'."
+          nil
+        end
+      end
+
+      def stdin?(filename)
+        %w[STDIN -].include?(filename)
+      end
+
+      class PDFFilter
+
+        def self.filter(file, &block)
+          PDF::Reader.new.parse(file, new(&block))
+        end
+
+        def initialize(&block)
+          @block = block
+        end
+
+        def show_text(string, *params)
+          @block[string << '|']
+        end
+
+        alias_method :super_show_text,                 :show_text
+        alias_method :move_to_next_line_and_show_text, :show_text
+        alias_method :set_spacing_next_line_show_text, :show_text
+
+        def show_text_with_positioning(params, *)
+          params.each { |param| show_text(param) if param.is_a?(String) }
+        end
+
+      end
+
+    end
+
+    # For backwards compatibility.
+    Textreader  = TextReader
+    Text_reader = TextReader
+
+  end
+
+end

data/lib/lingo/attendee/text_writer.rb

@@ -0,0 +1,169 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# Lingo -- A full-featured automatic indexing system                          #
+#                                                                             #
+# Copyright (C) 2005-2007 John Vorhauer                                       #
+# Copyright (C) 2007-2012 John Vorhauer, Jens Wille                           #
+#                                                                             #
+# Lingo is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# Lingo is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with Lingo. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+class Lingo
+
+  class Attendee
+
+    # Der TextWriter ermöglicht die Umleitung des Datenstroms in eine Textdatei. Dabei werden
+    # Objekte, die nicht vom Typ String sind in eine sinnvolle Textrepresentation gewandelt.
+    # Der Name der Ausgabedatei wird durch den Namen der Eingabedatei (des Textreaders) bestimmt.
+    # Es kann lediglich die Extension verändert werden. Der TextWriter kann auch das LIR-Format
+    # erzeugen.
+    #
+    # === Mögliche Verlinkung
+    # Erwartet:: Daten verschiedenen Typs
+    #
+    # === Parameter
+    # Kursiv dargestellte Parameter sind optional (ggf. mit Angabe der Voreinstellung).
+    # Alle anderen Parameter müssen zwingend angegeben werden.
+    # <b>in</b>:: siehe allgemeine Beschreibung des Attendee
+    # <b>out</b>:: siehe allgemeine Beschreibung des Attendee
+    # <b><i>ext</i></b>:: (Standard: txt2) Gibt die Dateinamen-Erweiertung für die Ausgabedatei an.
+    #                     Wird z.B. dem TextReader die Datei <tt>Dokument.txt</tt> angegeben und
+    #                     über die Lingo-Konfiguration alle Indexwörter herausgefiltert, kann mit
+    #                     <tt>ext: 'idx'</tt> der TextWriter veranlasst werden, die Indexwörter in
+    #                     die Datei <tt>Dokument.idx</tt> zu schreiben.
+    # <b><i>sep</i></b>:: (Standard: ' ') Gibt an, mit welchem Trennzeichen zwei aufeinanderfolgende
+    #                     Objekte in der Ausgabedatei getrennt werden sollen. Gängige Werte sind auch
+    #                     noch '\n', welches die Ausgabe jedes Objektes in eine Zeile ermöglicht.
+    # <b><i>lir-format</i></b>:: (Standard: false) Dieser Parameter hat keinen Wert. Wird er angegeben,
+    #                            dann wird er als true ausgewertet. Damit ist es möglich, die Ausgabedatei
+    #                            im für LIR lesbarem Format zu erstellen.
+    #
+    # === Beispiele
+    # Bei der Verarbeitung der oben angegebenen Funktionsbeschreibung des Textwriters mit der Ablaufkonfiguration <tt>t1.cfg</tt>
+    #   meeting:
+    #     attendees:
+    #       - text_reader:    { out: lines, files: '$(files)' }
+    #       - tokenizer:      { in: lines, out: token }
+    #       - word_searcher:  { in: token, out: words, source: 'sys-dic' }
+    #       - vector_filter:  { in: words, out: filtr, sort: 'term_rel' }
+    #       - text_writer:    { in: filtr, ext: 'vec', sep: '\n' }
+    # ergibt die Ausgabe in der Datei <tt>test.vec</tt>
+    #   0.03846 name
+    #   0.01923 ausgabedatei
+    #   0.01923 datenstrom
+    #   0.01923 extension
+    #   0.01923 format
+    #   0.01923 objekt
+    #   0.01923 string
+    #   0.01923 textdatei
+    #   0.01923 typ
+    #   0.01923 umleitung
+
+    class TextWriter < self
+
+      protected
+
+      def init
+        @ext = get_key('ext', 'txt2')
+        @lir = get_key('lir-format', false)
+        @sep = @lir ? ' ' : eval("\"#{@config['sep'] || ' '}\"")
+        @no_sep, @no_puts = true, false
+      end
+
+      def control(cmd, par)
+        case cmd
+          when STR_CMD_LIR
+            @lir = true
+          when STR_CMD_FILE
+            @no_sep = true
+
+            if stdout?(@ext)
+              @filename = @ext
+              @file = @lingo.config.stdout
+            else
+              @filename = par.sub(/(\.[^.]+)?$/, '.'+@ext)
+              @file = File.new(@filename,'w')
+              inc('Anzahl Dateien')
+            end
+
+            @lir_rec_no = ''
+            @lir_rec_buf = Array.new
+          when STR_CMD_RECORD
+            @no_sep = true
+            if @lir
+              flush_lir_buffer
+              @lir_rec_no = par
+            end
+          when STR_CMD_EOL
+            @no_sep = true
+            unless @lir
+              @file.puts unless @no_puts # unless @sep=="\n"
+              inc('Anzahl Zeilen')
+            end
+          when STR_CMD_EOF
+            flush_lir_buffer if @lir
+
+            unless stdout?(@filename)
+              @file.close
+              add('Anzahl Bytes', File.stat(@filename).size)
+            end
+        end
+      end
+
+      def process(obj)
+        if @lir
+          @lir_rec_buf << (obj.kind_of?(Token) ? obj.form : obj.to_s)
+        else
+          @file.print @sep unless @no_sep
+          @no_sep=false if @no_sep
+          if obj.is_a?(Word) || obj.is_a?(Token)
+            @file.print obj.form
+          else
+            @file.print obj
+          end
+        end
+      end
+
+      private
+
+      def flush_lir_buffer
+        unless @lir_rec_no.empty? || @lir_rec_buf.empty?
+          if @sep =~ /\n/
+            @file.print '*', @lir_rec_no, "\n", @lir_rec_buf.join(@sep), "\n"
+          else
+            @file.print @lir_rec_no, '*', @lir_rec_buf.join(@sep), "\n"
+          end
+        end
+        @lir_rec_no = ''
+        @lir_rec_buf.clear
+      end
+
+      def stdout?(filename)
+        %w[STDOUT -].include?(filename)
+      end
+
+    end
+
+    # For backwards compatibility.
+    Textwriter  = TextWriter
+    Text_writer = TextWriter
+
+  end
+
+end