sprache 0.0.1

data/bin/sprache

@@ -0,0 +1,486 @@
+#!/usr/bin/ruby
+puts '
+
+
+Verwendung:
+	Sprache started im interaktiven Modus wenn kein Argument gegeben ist.
+	Ist eine Datei als Argument gegeben wird diese interpretiert bevor der
+	interaktive Modus gestartet wird.
+
+
+sprache tutorial
+----------------
+
+Konventionen:
+	Es koennen Substantive, Adjektive und Verben verwendet werden
+	um Logik zu beschreiben.
+	Diese werden ab jetzt mit S, A und V abgekuerzt.
+
+Zuweisungen:
+	Adjektive und Verben koennen mit "ist", "hat" und "kann"
+	Substantiven zugewiesen werden. Die worte "der", "die", "das", 
+	"ein", "eine" und "einen" koennen fuer Lesbarkeit verwentet werden, 
+	werden jedoch vom Interpreter ignoriert.
+
+	> S ist A
+	> S kann V
+	> S hat S
+	> der S hat S
+	> S hat ein S
+	usw
+
+	zum Beispiel:
+
+	> Sprache ist toll
+	> der Schueler kann schreiben
+	> das Handy hat ein Tastenfeld
+
+	Zum Entfernen von Zuweisungen koennen die woerter "nicht", "kein",
+	"keine", "keinen" verwendet werden:
+
+	> S ist nicht A
+	> S kann nicht V
+	> S kann keinen V
+	> S hat kein S 
+	usw
+
+Fragen:
+	Zuweisungen koennen abgefragt werden durch.
+	> ist S A
+	> kann S V
+	> hat S S
+
+	Fragezeichen koennen zur Lesbarkeit angefuegt werden:
+	> ist S A?
+
+	Die antwort ist ja oder nein.
+
+	zum Beispiel:
+
+	> ist Sprache toll
+	  ja
+	> kann Schwein fliegen?
+	  nein
+
+Definitionen:
+	Definitionen sind gruppen von Zeilen die mit einem Verb assoziert sind
+	(siehe Aktionen).
+	In Definitionen kann "*", "er" uns "sie" mit dem ausfuehrenden 
+	Substantiv ersetzt und "es" mit dem Verb selbst
+	(siehe Aktionen).
+	Definitionen werden mit "vom" eingeleitet und enden mit einer Leerzeile
+	(auch in einer Datei). Im interaktiven Modus wechselt bei Definitionen
+	die Prompt von ">" nach "  -"
+
+	> vom V
+	  - ZEILE1
+	  - ZEILE2
+	   ...
+	  - ZEILEN
+	  -
+	>
+	  
+	zum Beispiel:
+
+	> vom schlafen
+	  - sub ist ausgeruht
+	  - bett ist zerknittert
+          -
+        >
+
+
+Aktionen:
+	Durch Aktionen koennen Definitionen ausgefuehrt werden:
+		
+	> S tut V
+
+	zum Beispiel:
+	
+	> Die Sonne tut scheinen
+	
+	Dies bewirkt auch, dass S V kann.
+
+Bedingungen:
+	Mit "wenn" koennen Bedingungen angefuegt werden.
+
+	> S ist A wenn S2 A2 ist
+	> S ist A wenn S2 V kann
+
+	Bedingungen koennen mit "und" oder "oder" erweitert werden.
+	Kommas koennen fuer lesbarkeit verwendet werden.	
+
+	> S ist A wenn S2 A2, A3 und A4 ist
+	> S ist A wenn S2 V, V2, oder V3 kann
+	
+	Durch "nicht", "kein", "keine" und "keinen" koennen bedingungen
+	negiert werden.
+
+	Globale Bedingungen:
+		Sind alle Bedingungen, die nicht in Definitionen vorkommen.
+		Sie werden gespeichert und pro zeile ausgewertet.
+		Wenn eine globale Bedingung nicht erfuellt wird, hat
+		die Zeile den umgekehrten effekt.
+		"er", "sie", "es" und "*" werden durch das Subjektiv am 
+		Anfang der Zeile ersetzt
+
+	Lokale Bedingungen:
+	       Sind bedingungen in definitionen.
+	       Sie werden nur beim ausfuehren der Aktion ausgewertet.
+	       Wenn eine lokale Bedingung nicht erfuellt ist, wird die
+	       Zeile ignoriert.
+	       "er", "sie" und "*" werden durch das Subjektiv am 
+	       Anfang der Zeile ersetzt. "es" wird durch den Namen der Aktion
+	       ersetzt.
+	
+
+Beschreiben:
+	Wenn nur der Name eines Substantives oder Verbes eingebeben wird, wird
+	es beschrieben.
+'
+
+$zeilen = ARGF.readlines if ARGV[0]
+$zeilen = [] unless $zeilen
+$zeile = -1
+
+def naechste_zeile prompt = "> "
+  $zeile += 1
+  zeile = $zeilen[$zeile] if $zeilen[$zeile]
+  unless zeile
+    printf prompt
+    zeile = STDIN.gets
+  end
+  unless zeile
+    puts
+    exit
+  end
+  zeile.gsub! /\beinen\b/, ""
+  zeile.gsub! /\beine\b/, ""
+  zeile.gsub! /\bein\b/, ""
+  zeile.gsub! /\der\b/, ""
+  zeile.gsub! /\die\b/, ""
+  zeile.gsub! /\das\b/, ""
+  zeile.gsub! ",", ""
+  zeile.gsub! "?", ""
+  return zeile
+end
+
+class Substantiv
+  attr_accessor :bezeichner, :adjektive, :verben, :besitz
+
+  def initialize bezeichner
+    @bezeichner = bezeichner
+    @adjektive = []
+    @verben = []
+    @besitz = []
+  end
+
+  def ist? adjektiv = nil
+    return true unless adjektiv
+    !!@adjektive.index(adjektiv)
+  end
+
+  def ist! adjektiv
+    @adjektive << adjektiv unless self.ist?(adjektiv)
+  end
+
+  def ist_nicht! adjektiv
+    @adjektive.delete adjektiv
+  end
+
+  def kann? verb = nil
+    return true unless verb
+    !!@verben.index(verb)
+  end
+
+  def kann! verb
+    @verben << verb unless self.kann?(verb)
+  end
+
+  def kann_nicht! verb
+    @verben.delete verb
+  end
+
+  def hat? besitz = nil
+    return true unless besitz
+    !!@besitz.index(besitz)
+  end
+
+  def hat! besitz
+    @besitz << besitz unless self.hat?(besitz)
+  end
+
+  def hat_nicht! besitz
+    @besitz.delete besitz
+  end
+end
+
+class Sprache
+  attr_accessor :substantive, :bedingungen
+
+  def initialize
+    @stimmt = true
+    @substantive = []
+    @definitionen = {}
+    @bedingungen = []
+  end
+
+  def index substantiv_bezeichner
+    @substantive.collect{|s| s.bezeichner}.index(substantiv_bezeichner)
+  end
+
+  def hole substantiv_bezeichner
+    if index(substantiv_bezeichner)
+      @substantive[index(substantiv_bezeichner)]
+    else
+      Substantiv.new(substantiv_bezeichner)
+    end
+  end
+
+  def ist substantiv_bezeichner, adjektiv = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if adjektiv
+      hole(substantiv_bezeichner).ist!(adjektiv)
+    end
+  end
+
+  def ist_nicht substantiv_bezeichner, adjektiv = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if adjektiv
+      hole(substantiv_bezeichner).ist_nicht!(adjektiv)
+    end
+  end
+
+  def kann substantiv_bezeichner, verb = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if verb
+      hole(substantiv_bezeichner).kann!(verb)
+    end
+  end
+
+  def kann_nicht substantiv_bezeichner, verb = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if verb
+      hole(substantiv_bezeichner).kann_nicht!(verb)
+    end
+  end
+
+  def hat substantiv_bezeichner, besitz = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if besitz
+      hole(substantiv_bezeichner).hat!(besitz)
+    end
+  end
+  
+  def hat_nicht substantiv_bezeichner, besitz = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if besitz
+      hole(substantiv_bezeichner).hat_nicht!(besitz)
+    end
+  end
+
+  def stimmt? substantiv, zuweisung, wort = nil
+    if zuweisung == "ist"
+      if (s = hole(substantiv)) and s.ist? wort
+        return true
+      else
+        return false
+      end
+    end
+
+    if zuweisung == "kann"
+      if (s = hole(substantiv)) and s.kann? wort
+        return true
+      else
+        return false
+      end
+    end
+
+    if zuweisung == "hat"
+      if (s = hole(substantiv)) and s.hat? wort
+        return true
+      else
+        return false
+      end
+    end
+
+  end
+
+  def zeile_interpretieren zeile
+    zeile.gsub! /\beinen\b/, ""
+    zeile.gsub! /\beine\b/, ""
+    zeile.gsub! /\bein\b/, ""
+    zeile.gsub! /\bder\b/, ""
+    zeile.gsub! /\bdie\b/, ""
+    zeile.gsub! /\bdas\b/, ""
+    zeile.gsub! ",", ""
+    zeile.gsub! "?", ""
+
+    woerter, bedingung = zeile.split("wenn")
+    woerter = woerter.split if woerter
+    bedingung = bedingung.split if bedingung
+    bedingung = [] unless bedingung
+    if bedingung.length > 1
+      zeile.gsub!(/\b\*\b/, woerter[0])
+      zeile.gsub!(/\ber\b/, woerter[0])
+      zeile.gsub!(/\bsie\b/, woerter[0])
+      zeile.gsub!(/\bes\b/, woerter[0])
+      @bedingungen << zeile unless @bedingungen.index(zeile) or @aktion
+      nicht = bedingung.delete "nicht"
+      nicht = bedingung.delete "kein" unless nicht
+      nicht = bedingung.delete "keine" unless nicht
+      nicht = bedingung.delete "keinen" unless nicht
+      logik = bedingung.delete("und") or bedingung.delete("oder")
+      if logik == "und"
+        stimmt = true
+        bedingung[1..-2].each  do |eigenschaft|
+          stimmt = false unless stimmt? bedingung[0], bedingung[-1], eigenschaft
+        end
+      elsif logik == "oder"
+        stimmt = false
+        bedingung[1..-2].each  do |eigenschaft|
+          stimmt = true if stimmt? bedingung[0], bedingung[-1], eigenschaft
+        end
+      else
+        stimmt = stimmt? bedingung[0], bedingung[2], bedingung[1]
+      end
+      @stimmt = stimmt
+      stimmt = stimmt.! if nicht
+      if (woerter.index("kein") or
+          woerter.index("keine") or
+          woerter.index("keinen") or
+          woerter.index("nicht")) and not stimmt
+        woerter.delete("nicht")
+        woerter.delete("kein")
+        woerter.delete("keine")
+        woerter.delete("keinen")
+      elsif not stimmt
+        woerter.insert(2, "nicht")
+      end
+    end
+
+    p = " "
+
+    if woerter.length == 1
+      if substantiv = hole(zeile[0..-2])
+        puts "#{p}"
+        if substantiv.adjektive != []
+          puts "#{p} ist:"
+          puts substantiv.adjektive.collect{|a| "#{p} - " + a}
+          puts "#{p}"
+        end
+
+        if substantiv.besitz != []
+          puts "#{p} hat:"
+          puts substantiv.besitz.collect{|a| "#{p} - " + a}
+          puts "#{p}"
+        end
+
+        if substantiv.verben != []
+          puts "#{p} kann:"
+          puts substantiv.verben.collect{|a| "#{p} - " + a}
+          puts "#{p}"
+        end
+        if (bedingungen = @bedingungen.collect{ |b| 
+              "#{p} - " + b if b[substantiv.bezeichner]
+            }) != []
+          puts "#{p} bedingungen:"
+          puts bedingungen
+          puts "#{p}"
+        end
+      end
+      if @definitionen.keys.index(zeile[0..-2])
+        puts @definitionen[zeile[0..-2]].split("\n").collect{|a| "#{p} - " + a}
+        puts "#{p}"
+      end
+    end
+
+    
+
+    if woerter.length > 1
+      nicht = woerter.delete "nicht"
+      nicht = woerter.delete "kein" unless nicht
+      nicht = woerter.delete "keine" unless nicht
+      nicht = woerter.delete "keinen" unless nicht
+      if woerter[1] == "ist"
+        if nicht
+          ist_nicht woerter[0], woerter[2]
+        else
+          ist woerter[0], woerter[2]
+        end
+      end
+      
+      if woerter[1] == "kann"
+        if nicht
+          kann_nicht woerter[0], woerter[2]
+        else
+          kann woerter[0], woerter[2]
+        end
+      end
+
+      if woerter[1] == "hat"
+        if nicht
+          hat_nicht woerter[0], woerter[2]
+        else
+          hat woerter[0], woerter[2]
+        end
+      end
+
+      if ["ist", "hat", "kann"].index(woerter[0])
+        if stimmt? woerter[1], woerter[0], woerter[2]
+          puts "  ja"
+        else
+          puts "  nein"
+        end
+      end
+
+      if woerter[0] == "vom"
+        @definitionen[woerter[1]] = ""
+        definieren = true
+        while definieren
+          zeile = naechste_zeile "... "
+          break if zeile == "\n"
+          @definitionen[woerter[1]] << zeile
+        end
+      end
+
+      if woerter[1] == "tut" and not nicht
+        subjektiv = woerter[0]
+        verb = woerter[2]
+	kann subjektiv, verb
+        if (funktion = @definitionen[woerter[2]])
+          funktion.split("\n").each do |zeile|
+            zeile.gsub!(/\*/, subjektiv)
+            zeile.gsub!(/\ber\b/, subjektiv)
+            zeile.gsub!(/\bsie\b/, subjektiv)
+            zeile.gsub!(/\bes\b/, verb)
+            @aktion = true
+            zeile_interpretieren zeile
+            @aktion = false
+          end
+        end
+      end
+    end
+  end
+end
+
+sprache = Sprache.new
+while true
+  sprache.bedingungen.each  do |b|
+    sprache.zeile_interpretieren b
+  end
+  zeile = naechste_zeile
+  redo unless zeile
+  sprache.zeile_interpretieren zeile
+end

data/sprache.rb

@@ -0,0 +1,359 @@
+#!/usr/bin/ruby
+
+require "dbg"
+$zeilen = ARGF.readlines if ARGV[0]
+$zeilen = [] unless $zeilen
+$zeile = -1
+
+def naechste_zeile prompt = "> "
+  $zeile += 1
+  zeile = $zeilen[$zeile] if $zeilen[$zeile]
+  unless zeile
+    printf prompt
+    zeile = STDIN.gets
+  end
+  unless zeile
+    puts
+    exit
+  end
+  zeile.gsub! /\beinen\b/, ""
+  zeile.gsub! /\beine\b/, ""
+  zeile.gsub! /\bein\b/, ""
+  zeile.gsub! /\der\b/, ""
+  zeile.gsub! /\die\b/, ""
+  zeile.gsub! /\das\b/, ""
+  zeile.gsub! ",", ""
+  zeile.gsub! "?", ""
+  return zeile
+end
+
+class Substantiv
+  attr_accessor :bezeichner, :adjektive, :verben, :besitz
+
+  def initialize bezeichner
+    @bezeichner = bezeichner
+    @adjektive = []
+    @verben = []
+    @besitz = []
+  end
+
+  def ist? adjektiv = nil
+    return true unless adjektiv
+    !!@adjektive.index(adjektiv)
+  end
+
+  def ist! adjektiv
+    @adjektive << adjektiv unless self.ist?(adjektiv)
+  end
+
+  def ist_nicht! adjektiv
+    @adjektive.delete adjektiv
+  end
+
+  def kann? verb = nil
+    return true unless verb
+    !!@verben.index(verb)
+  end
+
+  def kann! verb
+    @verben << verb unless self.kann?(verb)
+  end
+
+  def kann_nicht! verb
+    @verben.delete verb
+  end
+
+  def hat? besitz = nil
+    return true unless besitz
+    !!@besitz.index(besitz)
+  end
+
+  def hat! besitz
+    @besitz << besitz unless self.hat?(besitz)
+  end
+
+  def hat_nicht! besitz
+    @besitz.delete besitz
+  end
+end
+
+class Sprache
+  attr_accessor :substantive, :bedingungen
+
+  def initialize
+    @stimmt = true
+    @substantive = []
+    @definitionen = {}
+    @bedingungen = []
+  end
+
+  def index substantiv_bezeichner
+    @substantive.collect{|s| s.bezeichner}.index(substantiv_bezeichner)
+  end
+
+  def hole substantiv_bezeichner
+    if index(substantiv_bezeichner)
+      @substantive[index(substantiv_bezeichner)]
+    else
+      Substantiv.new(substantiv_bezeichner)
+    end
+  end
+
+  def ist substantiv_bezeichner, adjektiv = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if adjektiv
+      hole(substantiv_bezeichner).ist!(adjektiv)
+    end
+  end
+
+  def ist_nicht substantiv_bezeichner, adjektiv = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if adjektiv
+      hole(substantiv_bezeichner).ist_nicht!(adjektiv)
+    end
+  end
+
+  def kann substantiv_bezeichner, verb = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if verb
+      hole(substantiv_bezeichner).kann!(verb)
+    end
+  end
+
+  def kann_nicht substantiv_bezeichner, verb = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if verb
+      hole(substantiv_bezeichner).kann_nicht!(verb)
+    end
+  end
+
+  def hat substantiv_bezeichner, besitz = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if besitz
+      hole(substantiv_bezeichner).hat!(besitz)
+    end
+  end
+  
+  def hat_nicht substantiv_bezeichner, besitz = nil
+    unless index(substantiv_bezeichner)
+      @substantive << Substantiv.new(substantiv_bezeichner)
+    end
+    if besitz
+      hole(substantiv_bezeichner).hat_nicht!(besitz)
+    end
+  end
+
+  def stimmt? substantiv, zuweisung, wort = nil
+    if zuweisung == "ist"
+      if (s = hole(substantiv)) and s.ist? wort
+        return true
+      else
+        return false
+      end
+    end
+
+    if zuweisung == "kann"
+      if (s = hole(substantiv)) and s.kann? wort
+        return true
+      else
+        return false
+      end
+    end
+
+    if zuweisung == "hat"
+      if (s = hole(substantiv)) and s.hat? wort
+        return true
+      else
+        return false
+      end
+    end
+
+  end
+
+  def zeile_interpretieren zeile
+    zeile.gsub! /\beinen\b/, ""
+    zeile.gsub! /\beine\b/, ""
+    zeile.gsub! /\bein\b/, ""
+    zeile.gsub! /\bder\b/, ""
+    zeile.gsub! /\bdie\b/, ""
+    zeile.gsub! /\bdas\b/, ""
+    zeile.gsub! ",", ""
+    zeile.gsub! "?", ""
+
+    woerter, bedingung = zeile.split("wenn")
+    woerter = woerter.split if woerter
+    bedingung = bedingung.split if bedingung
+    bedingung = [] unless bedingung
+    if bedingung.length > 1
+      zeile.gsub!(/\b\*\b/, woerter[0])
+      zeile.gsub!(/\ber\b/, woerter[0])
+      zeile.gsub!(/\bsie\b/, woerter[0])
+      zeile.gsub!(/\bes\b/, woerter[0])
+      @bedingungen << zeile unless @bedingungen.index(zeile) or @aktion
+      nicht = bedingung.delete "nicht"
+      nicht = bedingung.delete "kein" unless nicht
+      nicht = bedingung.delete "keine" unless nicht
+      nicht = bedingung.delete "keinen" unless nicht
+      logik = bedingung.delete("und") or bedingung.delete("oder")
+      if logik == "und"
+        stimmt = true
+        bedingung[1..-2].each  do |eigenschaft|
+          stimmt = false unless stimmt? bedingung[0], bedingung[-1], eigenschaft
+        end
+      elsif logik == "oder"
+        stimmt = false
+        bedingung[1..-2].each  do |eigenschaft|
+          stimmt = true if stimmt? bedingung[0], bedingung[-1], eigenschaft
+        end
+      else
+        stimmt = stimmt? bedingung[0], bedingung[2], bedingung[1]
+      end
+      @stimmt = stimmt
+      stimmt = stimmt.! if nicht
+      woerter.insert(2, "nicht") unless stimmt
+    end
+
+    if woerter.length == 1
+      if substantiv = hole(zeile[0..-2])
+        puts "#"
+        if substantiv.adjektive != []
+          puts "# ist:"
+          puts substantiv.adjektive.collect{|a| "# - " + a}
+          puts "#"
+        end
+
+        if substantiv.besitz != []
+          puts "# hat:"
+          puts substantiv.besitz.collect{|a| "# - " + a}
+          puts "#"
+        end
+
+        if substantiv.verben != []
+          puts "# kann:"
+          puts substantiv.verben.collect{|a| "# - " + a}
+          puts "#"
+        end
+        if (bedingungen = @bedingungen.collect{ |b| 
+              "# - " + b if b[substantiv.bezeichner]
+            }) != []
+          puts "# bedingungen:"
+          puts bedingungen
+          puts "#"
+        end
+      end
+      if @definitionen.keys.index(zeile[0..-2])
+        puts @definitionen[zeile[0..-2]].split("\n").collect{|a| "# - " + a}
+        puts
+      end
+    end
+
+    if woerter.delete("und") or woerter.delete("aber")
+      zeilen = []
+      woerter[2..-1].each do |wort|
+        zeilen << (woerter[0..1]+ [wort]).join(" ")
+      end
+
+      zeilen.each_with_index do |zeile, i|
+        zeile = zeile.dup.split()
+        if ["nicht", "kein", "keine", "keinen"].index(zeile[-1])
+          nicht_einfuegen = true
+          zeilen.delete_at(i)
+        end
+        if nicht_einfuegen
+          zeilen[i] = zeilen[i].split.insert(2, "nicht").join(" ")
+          nicht_einfuegen = false
+        end
+      end
+      zeilen.each do |zeile|
+        zeile = zeile.split.insert(2, "nicht").join(" ") unless @stimmt
+        zeile_interpretieren(zeile)
+      end
+      @stimmt = true
+    end
+
+    if woerter.length > 1
+      nicht = woerter.delete "nicht"
+      nicht = woerter.delete "kein" unless nicht
+      nicht = woerter.delete "keine" unless nicht
+      nicht = woerter.delete "keinen" unless nicht
+      if woerter[1] == "ist"
+        if nicht
+          ist_nicht woerter[0], woerter[2]
+        else
+          ist woerter[0], woerter[2]
+        end
+      end
+      
+      if woerter[1] == "kann"
+        if nicht
+          kann_nicht woerter[0], woerter[2]
+        else
+          kann woerter[0], woerter[2]
+        end
+      end
+
+      if woerter[1] == "hat"
+        if nicht
+          hat_nicht woerter[0], woerter[2]
+        else
+          hat woerter[0], woerter[2]
+        end
+      end
+
+      if ["ist", "hat", "kann"].index(woerter[0])
+        if stimmt? woerter[1], woerter[0], woerter[2]
+          puts "  ja"
+        else
+          puts "  nein"
+        end
+      end
+
+      if woerter[0] == "vom"
+        @definitionen[woerter[1]] = ""
+        definieren = true
+        while definieren
+          zeile = naechste_zeile "... "
+          break if zeile == "\n"
+          @definitionen[woerter[1]] << zeile
+        end
+      end
+
+      if woerter[1] == "tut" and not nicht
+        hole(woerter[0]).kann! woerter[2]
+        subjektiv = woerter[0]
+        verb = woerter[2]
+        if (funktion = @definitionen[woerter[2]])
+          funktion.split("\n").each do |zeile|
+            zeile.gsub!(/\*/, subjektiv)
+            zeile.gsub!(/\ber\b/, subjektiv)
+            zeile.gsub!(/\bsie\b/, subjektiv)
+            zeile.gsub!(/\bes\b/, verb)
+            @aktion = true
+            zeile_interpretieren zeile
+            @aktion = false
+          end
+        end
+      end
+    end
+  end
+end
+
+sprache = Sprache.new
+while true
+  sprache.bedingungen.each  do |b|
+    sprache.zeile_interpretieren b
+  end
+  zeile = naechste_zeile
+  redo unless zeile
+  sprache.zeile_interpretieren zeile
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: sprache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Justin Massey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-06 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- sudoer86@gmail.com
+executables:
+- sprache
+extensions: []
+extra_rdoc_files: []
+files:
+- sprache.rb
+- bin/sprache
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: experimentele skriptsprache mit tutorial
+test_files: []