Wadoku.de Forum
  [Search] Search   [Recent Topics] Recent Topics   [Hottest Topics] Hottest Topics  
[Register] Register /  [Login] Login 
Wadoku für Mac OS X Lexikon/Dictionary.app (9. Januar 2011)  RSS feed
Forum Index » Japanisch auf PC/PDA
Author Message
system



Joined: 29/12/2009 08:46:05
Messages: 142
Offline

Basierend auf den XML-Daten vom 9. Januar 2011 von hier. Sollte ab Mac OS X 10.5 funktionieren.

Den Order "Wadoku.dictionary" einfach nach ~/Library/Dictionaries oder /Library/Dictionaries kopieren, dann einfach Lexikon/Dictionary.app neu starten.

image

EDIT: Aktuelle Versionen sind unter (http://www.wadoku.de/wiki/display/WAD/Downloads+und+Links) verlinkt.
timewastin



Joined: 03/04/2010 23:11:00
Messages: 3
Offline

super, danke!

ich kann irgendwie nur von japanisch nach deutsch suchen..gibts das auch von deutsch nach japanisch, oder mach ich nur was falsch?
system



Joined: 29/12/2009 08:46:05
Messages: 142
Offline

timewastin wrote:ich kann irgendwie nur von japanisch nach deutsch suchen..gibts das auch von deutsch nach japanisch, oder mach ich nur was falsch?

Wadoku ist nur Japanisch-Deutsch. Entsprechend habe ich auch nur die japanischen Wörter in den Index hinzugefügt. Du machst also nichts falsch.

Mal sehen, vielleicht kann ich ja noch irgendwie die deutschen Begriffe rausfiltern (leider sind die einzelnen Einträge nicht einheitlich) und auch in den Index packen. Eventuell könnte man auch noch ローマ字-Suche hinzufügen.
timewastin



Joined: 03/04/2010 23:11:00
Messages: 3
Offline

achso, wirklich? das wusste ich nicht...ich hatte unter windows das "Wadoku EPWING 2005 (25MB)" und konnte da "beidseitig" suchen...

weißt du vielleicht sonst von einem ja-de/de-ja Dictionary für Mac?
system



Joined: 29/12/2009 08:46:05
Messages: 142
Offline

Etwas kostenloses für die Gegenrichtung wäre etwa http://www5.mediagalaxy.co.jp/sanshushadj/:

image

image


Ansonsten einfach mal hier lesen:
http://www.wadoku.de/forum/posts/list/888.page#6718

Bei Amazon findet man auch eine Menge, leider sind die umfangreichen Wörterbücher für so ein exotisches Sprachpaar wie Deutsch-Japanisch nicht gerade besonders kostengünstig, etwa http://www.amazon.de/Grosses-Deutsch-Stichwörtern-Allgemeinwortschatz-soziopolitische/dp/3896872885/ oder http://www.amazon.de/Neues-deutsch-japanisches-japanischer-Lautschrift/dp/383591054X/ oder http://www.amazon.de/Deutsch-Japanisch-Wörterbuch-Doku-Wa-Jiten-japanischen-Gegenwartssprache/dp/3896872338/
timewastin



Joined: 03/04/2010 23:11:00
Messages: 3
Offline

danke! aber die sind ja auch nicht für Dictionary.app...

denke, ich werde einfach das mitgelieferte jap-eng benutzen
system



Joined: 29/12/2009 08:46:05
Messages: 142
Offline

timewastin wrote:danke! aber die sind ja auch nicht für Dictionary.app...

Besorg irgendein gutes Deutsch-Japanisch-Wörterbuch im passenden Format (etwa EPWING, ...), dann kann ich es dir für MacOSX-Dictionary.app konvertieren.
boscowitch



Joined: 23/09/2008 16:03:04
Messages: 231
Location: ケルン
Offline

alternativ nimm wadoku und konvertiers für dictionary app , einfahste art jap und deutsch vertauschen ^^ zwar niich perfekt aber es funktioniert eigermanse, besser noch sogar die deutschen wörter in der übersetzung nach ; trennen udn merfach eintragen machen ... muss ich mal machen für meine wadoku version ... wer sich mit sqlite3 auskennt müsste es auch hinbekommen , hier im vorum gibt es einige projekte die das wadoku als sqlite datenbank mitschleppen...
ich hab momentan leide rkeine zeit bzw mac ^^
system



Joined: 29/12/2009 08:46:05
Messages: 142
Offline

Hier noch der Beitrag zu den alten Daten von Ende 2009.

Basierend auf der Gjiten-Version vom 20. Dezember 2009 von hier. Sollte ab Mac OS X 10.5 funktionieren; wurde aber nur mit 10.6.2 und 10.6.3 getestet.

Entpacken und nach ~/Library/Dictionaries oder /Library/Dictionaries kopieren, dann einfach Lexikon/Dictionary neu starten.

Downloadlink:
http://rapidshare.com/files/327430334/Wadoku.dictionary.zip (82,4 MB)

image

Hier das Perl-Skript zum selber konvertieren:
#!/usr/bin/perl -w
use strict;
use utf8;

binmode STDOUT, ":utf8";
open FH,"<:encoding(utf-8)","WADOKUJT.txt" or die "could not open dict";
print qq(<?xml version="1.0" encoding="UTF-8"?>\n);
print qq(<d:dictionary xmlns="http://www.w3.org/1999/xhtml" xmlns:d="http://www.apple.com/DTDs/DictionaryService-1.0.rng">\n);

my @bdl;
my @lel;
my @wwl;
while(my $entry = <FH>) {
    chop($entry);
    if($entry =~ m!([^[]+) \[([^\]]+)\] (.*)$!) {
        my $lesung = $2;
        my $woeter = $1;
        my $bedeutung = $3;
        push @bdl,$bedeutung;
        push @wwl,$woeter;
        push @lel,$lesung;
    } else {
        $bdl[-1]=$bdl[-1].$entry;
    }    
}

sub safe($) {
    my $wort = pop();
    $wort =~ s/&/&/g;
    $wort =~ s/\>/>/g;
    $wort =~ s/\</</g;
    $wort =~ s/"/"/g;
    $wort =~ s/'/&apos;/g;
    $wort =~ s!\x0B!!g;
    $wort =~ s!\x10!!g;
    return $wort;
}

for(my $i=0; $i < $#wwl; $i++) {
    my $bedeutung = safe($bdl[$i]);
    my $lesung = safe($lel[$i]);
    my $haupt = safe($wwl[$i]);
    my @einzel = split(/ /,$haupt);
    $haupt =~ s! !; !g;
    print qq(<d:entry id="eintrag-$i" d:title="$haupt">\n);
    for(@einzel) {
        print qq(<d:index d:value="$_" d:title="$_" d:yomi="$lesung" />\n);
    }
    print qq(<h1><span class="headword">$haupt</span> <span class="hyouki">【$lesung】</span></h1>\n);
    $bedeutung =~ s!^/!!;
    $bedeutung =~ s!/$!!;
    $bedeutung =~ s!\s*/\s*!; !g;
    $bedeutung =~ s!^\s*!!;
    $bedeutung =~ s!\s*$!!;
    print qq(<div class="meaning">$bedeutung</div>\n);
    print qq(</d:entry>\n);
}
close FH;
print qq(</d:dictionary>\n);
Die Ausgabe dieses Perl-Skripts einfach als /Developer/Extras/Dictionary Development Kit/project_templates/MyDictionary.xml speichern und dann "make" im selben Verzeichnis aufrufen und schon sollte das Wörterbuch erstellt werden. Zum Erstellen von Wörterbüchern muss XCode installiert sein.

Ich hatte auch mal die Edict2-Version konvertiert. Die ist aber älter (Februar 2009). http://rapidshare.com/files/327377080/WadokuMac.sitx (74 MB). Das Skript dazu gibt es auf Nachfrage. Ich kann auch noch C-Quellcode anbieten mit dem man EPWING-Datei in flache Textdateien konvertiert.
system



Joined: 29/12/2009 08:46:05
Messages: 142
Offline

Die XML-Daten von Januar 2011 wurden mit diesem Perl-Skript umgewandelt. Es sind noch ein paar Sachen dabei, die schlecht formatiert werden und ein paar Sachen werden einfach komplett ignoriert. Ich hatte auch mal mit der Umwandlung zu Romaji herumgespielt, aber leider wurde da immer irgendwas falsch umgewandelt. Eventuell könnte man da noch mal hier im Java-Quellcode nachlesen, wie man das richtig macht.

#!/opt/local/bin/perl
use strict;
use warnings;
use XML::Twig;
use utf8;
use Data::Dumper;
use HTML::Entities;
binmode STDOUT, ":utf8";
binmode STDERR, ":utf8";
#require 'Kana.pl';#kana2romaji

open(XML, '>', "wadoku.xml") or die $!;
binmode XML, ":utf8";
print XML qq'<?xml version="1.0" encoding="UTF-8"?>\n';
print XML qq'<d:dictionary xmlns="http://www.w3.org/1999/xhtml" xmlns:d="http://www.apple.com/DTDs/DictionaryService-1.0.rng">\n';
my $i=0;

my $t = XML::Twig->new(
	twig_handlers => {
		entry => \&entry
	}
);
$t->parsefile( 'wadoku');
print XML qq'</d:dictionary>';
close XML; 

sub flatten 
{
	my ($t) = @_;
	
	if($t->has_children()) {
		my @children = $t->children();
		my $output = "";
		foreach my $c (@children) {
			if($c->tag eq 'token') 
			{
				my $type = $c->att('type')||"N";
				die "bad type: $type\n" if $type ne 'N';
				my $gen = $c->att('genus') || "";
				my $num = $c->att('numerus')||"";
				if("$gen$num" ne "") {
					$output .= flatten($c);#.qq!<span class="genus"> $gen$num </span>!;
				} else{
					$output .= flatten($c);#.qq!<span class="genus"> (NAr) </span>!;
				}
			} elsif($c->tag eq 'text') {
				my $nach = $c->att('hasFollowingSpace')||"";
				my $vor = $c->att('hasPrecedingSpace')||"";
				$output .= " " if $vor;
				$output .= flatten($c);
				$output .= " " if $nach;
			} elsif($c->tag eq 'bracket') {
				my $x = flatten($c);
				$x =~ s!;? $!!;
				$output .= qq!<span class="klammer"> (!.$x.") </span>";
			} elsif($c->tag eq 'tr') {
				$output .= flatten($c)."; ";
			} elsif($c->tag eq 'def') {
				$output .= flatten($c)."; ";
			} elsif($c->tag eq '#PCDATA') {
				$output .= encode_entities($c->text,'<>&"');
			} elsif($c->tag eq 'ref') {
				my $id = $c->att('id');
				my $type = $c->att('type');
				my $jap = $c->first_child('jap');
				if((not defined $jap) || (not defined $type)) {
						my $x = flatten($c);
						$output .= qq!<span class="ref">!.$x." </span>";
						#print "\n$x\n";
						#print "\n";
						#$c->print;
						#print "\n";
						#$t->print;
						#print "\n";
						#die "not ref";
				} else {		
					$jap = flatten($jap);
					$type =~ s!^altread$!→!;
					$type =~ s!^syn$!⇒!;
					$type =~ s!^anto$!⇔!;
					if(defined $id) {
						$output .= qq!<a href="x-dictionary:r:wadoku$id">$type ($jap)</a>; !;
					} else {
						$output .= qq!<a href="x-dictionary:d:$jap">$type ($jap)</a>; !;
					}
				}
			} elsif($c->tag eq 'foreign') {
				$output .=  '<span class="foreign">'.flatten($c)." </span>";
			} elsif($c->tag eq 'emph') {
				$output .=  '<em>'.flatten($c)."</em>";
			} elsif($c->tag eq 'etym') {
				$output .=  '<span class="etym">'.flatten($c)." </span>";
			} elsif($c->tag eq 'title') {
				$output .=  '<span class="title">'.flatten($c)." </span>";
			} elsif($c->tag eq 'date') {
				$output .=  '<span class="date">'.flatten($c)." </span>";
			} elsif($c->tag eq 'birthdeath') {
				$output .=  '<span class="birthdeath">'.flatten($c)."</span>";
			} elsif($c->tag eq 'impli') {
					#keine ausgabe
			} elsif($c->tag eq 'usg') {
					my $type = $c->att('type')||"";
					my $reg = $c->att('reg');
					if($type eq "") {
						if(not defined $reg) {
							#print "\n";
							#$c->print;
							#print "\n";
							#$t->print;
							#print "\n";
							#die "no reg";
						} else {
							$reg = ucfirst $reg;
							$output .= qq'<span class="register">$reg </span> ';
						}
					} else {
					if($type eq 'hint') {
						$output .= '<span class="rel">||</span> ';
					} 
					elsif($type eq 'dom') {
						$output .=  '<span class="dom">'.flatten($c)." </span>";
					}
					elsif($type eq 'abrev') {
						$output .=  '<span class="abrev">'.flatten($c)." </span>";
					}
					elsif($type eq 'time') {
						$output .=  '<span class="time">'.flatten($c)." </span>";
					}
					else {
						print "\n";
						$c->print;
						print "\n";
						$t->print;
						print "\n";
						die "rel $type";
					}
					}
			} else {
			    my $x =  '<span class="'.$c->tag.'">'.flatten($c)." </span>";
				$output .= $x;
				if($c->tag ne 'trans'
				&& $c->tag ne 'expl'
				&& $c->tag ne 'famn'
				&& $c->tag ne 'transl'
				&& $c->tag ne 'topic'
				&& $c->tag ne 'literal'
				&& $c->tag ne 'deu_gr'
				&& $c->tag ne 'specchar'
				&& $c->tag ne 'iron'
				&& $c->tag ne 'jap'
				&& $c->tag ne 'descr'
				&& $c->tag ne 'transcr'
				&& $c->tag ne 'expli') {
					print "\n".$c->tag;
					print "\n";
					$c->print;
					print "\n";
					$t->print;
					print "\n";
					print "$output\n";
					die "handle me";
					#$c->print;
					#print "\nx: $output\n";
				}
			}
		}
		return $output;
	} 
	else {
	 	return $t->text();
	}
}

sub entry 
{
	my ($t, $entry) = @_;
	
	my $id = $entry->att('id');
	if((not defined $id) || (not $id =~ m!^[0-9]+$!)) {
		$entry->print;
		exit;
	}
	
	my @form = $entry->children('form');
	
	if(length @form != 1) {
		$entry->print;
		exit;
	}
	
	my @orth = $form[0]->children('orth');
	if(length @orth < 1) {
		$entry->print;
		exit;
	}	
	
	my @pron = $form[0]->children('pron');
	if(length @pron < 1) {
		$entry->print;
		exit;
	}
	
	my $lemma = undef;
	my $schreibweise = "";
	foreach my $orth (@orth) {
		my $o = $orth->text;
		my $is_lemma = $orth->att('midashigo') || "";
		$lemma = $o if $is_lemma or not defined $lemma;
		my $is_irr = $orth->att('irr') || "";
		$schreibweise .= "$o; ";
	}
	$schreibweise =~ s!; $!!;
	
	if(not defined $lemma) {
		$entry->print;
		exit;
	}
	
	$lemma =~ s!×!!g;
	$lemma =~ s!△!!g;
	$lemma = encode_entities($lemma,'<>&"');
	#print "lemma: $lemma\n";
	
	my $aussprache = undef;
	my $aussprachen = "";
	foreach my $pron (@pron) {
		my $is_hatsuon = $pron->att('type') || "";
		if($is_hatsuon) {
			my $p = $pron->text;
			#my $romaji = kana2romaji($p);
			#$romaji =~ s!/!!g;
			#$romaji =~ s!<!!g;
			#$romaji =~ s!>!!g;
			#$romaji =~ s!ux!u!g;
			#$romaji =~ s!doxu!du!g;
			#$romaji =~ s!dexy!dy!g;
			#$romaji =~ s!u゛x(.)!v$1!g; # fix va, vi, ve ...
			#$romaji =~ s!\[Gr\](.)!uc $1!eg;
			#$romaji =~ s!\[Jo\]ha!wa!g;
			#$romaji =~ s!\[Jo\]he!e!g;
			#$romaji =~ s!wo!o!g;
			#$romaji =~ s!\[Dev\]([^aiueo]*)([aiueo])!$1<span class="devok">$2</span>!g;
			#$romaji =~ s!\[[^]]*\]!!g;
			#$romaji =~ s! ! !g;
			#$romaji =~ s!、!,!g;
			#$romaji =~ s!。!.!g;
			#$romaji =~ s!dexi!di!g;
			#$romaji =~ s!ixyu!yu!g;
			#$romaji =~ s!ixyo!yo!g;
			#$romaji =~ s!ixya!ya!g;
			#$romaji =~ s!ixe!ye!g;
			#$romaji =~ s!fuxa!a!g;
			#$romaji =~ s!jixe!je!g;
			#$romaji =~ s!_!!g;
			#$romaji =~ s!'!!g;
			#$romaji =~ s!・!!g;
			#$romaji =~ s!’!!g;
			#$romaji =~ s!・!!g;
			#$romaji =~ s!っ(.)!$1$1!g;
			#$romaji =~ s!&!&!g;
			
			$p =~ s!×!!g;
			$p =~ s!△!!g;
			$p =~ s!〈!!g;
			$p =~ s!〉!!g;
			$p =~ s!\{([^ ]+)\}!$1!g;
			$p =~ s!\[[^]]*\]!!g;
			$p =~ s!_!!g;
			$p =~ s!'!!g;
			$p =~ s!・!!g;
			$p =~ s!/!!g;
			$p =~ s!<!!g;
			$p =~ s!>!!g;
			$p =~ s!’!!g;
			$p =~ s!・!!g;
			$p =~ s!~!!g;
			$p = encode_entities($p,'<>&"');
			#$aussprachen .= "$p $romaji; ";
			$aussprachen .= "$p; ";
		}
	}
	$aussprachen =~ s!; $!!g;
	
	my @sense = $entry->children('sense');
	if(length @sense < 1) {
		$entry->print;
		exit;
	}
	
	my $yomi;
	
	foreach my $pron (@pron) {
		my $p = $pron->text;
		my $is_hatsuon= $pron->att('type') || "";
		if($is_hatsuon) {
			$p =~ s!×!!g;
			$p =~ s!△!!g;
			$p =~ s!〈!!g;
			$p =~ s!〉!!g;
			$p =~ s!\{([^ ]+)\}!$1!g;
			$p =~ s!'!!g;
			$p =~ s!\[[^]]*\]!!g;
			$p =~ s!/!!g;
			$p =~ s!<!!g;
			$p =~ s!>!!g;
			$p =~ s!\s+!!g;
			$p =~ s!・!!g;
			$p =~ s!_!!g;
			$p =~ s!’!!g;
			$p =~ s!…!!g;
			$p =~ s!~!!g;
			$p = encode_entities($p,'<>&"');
			$yomi = $p;
		}
	}
	
	if(not defined $yomi) {
		foreach my $pron (@pron) {
			my $p = $pron->text;
			$p =~ s!×!!g;
			$p =~ s!△!!g;
			$p =~ s!〈!!g;
			$p =~ s!〉!!g;
			$p =~ s!\{([^ ]+)\}!$1!g;
			$p =~ s!'!!g;
			$p =~ s!\[[^]]*\]!!g;
			$p =~ s!/!!g;
			$p =~ s!<!!g;
			$p =~ s!>!!g;
			$p =~ s!\s+!!g;
			$p =~ s!・!!g;
			$p =~ s!_!!g;
			$p =~ s!’!!g;
			$p =~ s!…!!g;
			$p =~ s!~!!g;
			$p = encode_entities($p,'<>&"');
			$yomi = $p;
		}
	}
	
	die "no yomi\n" if not defined $yomi;
	
	print XML qq!<d:entry id="wadoku$id" d:title="$lemma">!;
	foreach my $orth (@orth) {
		my $o = $orth->text;
		$o =~ s!…!!g;
		$o =~ s!×!!g;
		$o =~ s!△!!g;
		$o =~ s!〈!!g;
		$o =~ s!〉!!g;
		$o =~ s!\{([^ ]+)\}!$1!g;
		if($o =~ m!\([^)]*\)!) {
			while($o =~ s!([^;]*)\(([^)]*)\)([^;]*)!$1$2$3;$1$3!g) {};
		}
		my @x = split ";",  $o;
		foreach my $x (@x)  {
			$x = encode_entities($x,'<>&"');
			print XML qq!<d:index d:value="$x" d:yomi="$yomi"/>!;
		}
	}
	
	foreach my $pron (@pron) {
		my $p = $pron->text;
		my $is_hatsuon= $pron->att('type') || "";
		
		if(not $is_hatsuon) {
			#my $romaji = kana2romaji($p);
			#$romaji =~ s!u゛x(.)!v$1!g;
			#$romaji =~ s! ! !g;
			#$romaji =~ s!、!,!g;
			#$romaji =~ s!。!.!g;
			$p = encode_entities($p,'<>&"');
			#$romaji = encode_entities($romaji,'<>&"');
			print XML qq!<d:index d:title="$lemma" d:value="$p" d:yomi="$yomi"/>!;
			#print XML qq!<d:index d:title="$lemma" d:value="$romaji" d:yomi="$yomi"/>!;
		}
	}
	
	my $bedeutung = "";
	my $cnt=0;
	my $ms = @sense;
	foreach my $sense (@sense) {
			my $eintrag = flatten($sense);
			$eintrag =~ s!; $!!;
			$cnt++;
			$bedeutung .= " " if $ms>1 && $cnt!=1;
			#$bedeutung .= "<p>";
			$bedeutung .= "[$cnt] " if $ms>1;
			$bedeutung .= $eintrag;
			#$bedeutung .= "</p>";
	}
	
	#print "bedeutung: $bedeutung\n";
	
	#exit if $i++>100;
	
	print XML qq!<div><h1><span class="headword">$lemma</span> <span class="hyouki">【$aussprachen】</span></h1></div>!;
	#print XML qq!<div class="hyouki">【$aussprachen】</div>!;
	print XML qq!<div class="meaning">$bedeutung</div>!;
	print XML qq!</d:entry>\n!;
	$entry->purge;
	return 1;
}
boscowitch



Joined: 23/09/2008 16:03:04
Messages: 231
Location: ケルン
Offline

mist ich wurde geschlagen ich arbeite gerade an nem universelleren OOP vala convertierungs tool das jetzt als erstes ne klasse

WadokuXmlImporter hat und nen GjitenExporter

ich versuche gerade änliche zu convertierne wie mein alter rip mit ungefähr gleich viel informationen, momentna sieht so ne gjiten zeile z.b. so aus:

日本語 [にほんご] /{Sprache} Japanisch, japanische Sprache/
南部 [なんぶ] /{Familienn.} Nanbu{Ortsn.} Nanbu (in der Präf. Aomori) {Gesch.} die Südstaaten, die Konföderation/

edit: (habs mal einfachheitshalber wieder auf ; gestellt sieht nun so aus):
南部 [なんぶ] /{Familienn.} Nanbu ; {Ortsn.} Nanbu in der Präf. Aomori ; {Gesch.} die Südstaaten ; die Konföderation ;/

(die spaces vor den ; sind noch debbuing und kommen warsch weg)

(das [] und / / ist gjiten txt formating)
momentan gibts noch probleme die , und ; exact wie in der online version zu setzten, aber das wird bestimmt noch muss noch nen bissel mehr mti libxml2 spielen da ich sie zum erstenmal benutze.

der grund ist vorallem auch das ich auch nen WadokuNotifySqliteExporter und ein
EDICT bzw JMDictXmlImporter machen will damit ich auch ein englishes edict-notify anbieten kann, natürlich kann ich mich dann auch an ein Mac OS X Lexikon Exporter einbaun sobalts geht, und viele weitere formate

sobalt es einigermasen geht werd ich mal am besten ein github acc dafür machen...

hier nen kleienr ausblick auf den importer is eingelicht recht simples oop muss man sich nur ableiten und
read_next_entry() implementieren:
public class Entry {
    
    public string midashigo { get; set; default=""; }
    public string writings  { get; set; default=""; }
    public string reading   { get; set; default=""; }
    public string translation { get; set; default=""; }
    
}

public abstract class XmlImporter : GLib.Object {
    protected Xml.TextReader reader;
    
    public string separator { get; set; default=","; }
    
    public XmlImporter(string path) {
        reader = new TextReader.filename(path);
    }
    
    public abstract Entry read_next_entry();
    
    ~XmlImporter() {
        reader.close();
    }
}


so jetzt aber spät morgen mal alles auf github pushen...
Dan


[Avatar]

Joined: 24/05/2006 16:58:45
Messages: 1243
Offline

Warum das Ganze nicht einfach per XSL? Ich hab hier mal fix was gebastelt (https://gist.github.com/813338), das sieht auf den ersten Blick schon recht gut aus (siehe Bild), wie ich finde. Natürlich sind noch einige Macken drin, die ausgebügelt werden müssen. Die bisherigen Exports (Edict) werden auch per XSL realisiert, deshalb würde ich es begrüssen, wenn ihr vielleicht daran mitarbeiten könntet.

Ich war so frei, die Version von system auf dem Server hier zu spiegeln (http://www.wadoku.de:81/downloads/Wadoku.dictionary.dmg). Hat mich einige Mühen gekostet, das überhaupt erstmal von Rapidshare auf den Server zu kriegen :/
[Thumb - スクリーンショット(2011-02-06 13.32.42).png]


無知の知
boscowitch



Joined: 23/09/2008 16:03:04
Messages: 231
Location: ケルン
Offline

hmm stimmt xsl macht sinn für convertierung in andere txt basierte formate und ist auch recht mächtig.

leider habe ich seit ~6 jahren nicht mehr XLS geschreiben, also meine erfahrung ist so gut wie weg,

auserdem würde ich torzdem gern ein tool haben, ich schau mit mal zusätzlich zu libxml noch libxslt an damit könnte man dann auch ein XSLT converter/importer/exporter machen, haupsächlich wird das tool auch nötig sein für export in formaten mit einer indexierung ect wie indexed sqlite bzw dict o.ä.

eine frage hätt ich aber noch wie performant ist so ein XSLT durchlauf ?
grad im bezug auf ram (ich hab grad mein programm komplett umgesellt auf einen XmlTextReader da der ram verbrauch und geschwindigkeit von einem abstracten reader mit trees im ram ect sehr hoch ist und viel länger braucht und gegebenfalls sogar mit 4Gb ram vom system getötet worden ist.
Dan


[Avatar]

Joined: 24/05/2006 16:58:45
Messages: 1243
Offline

XSL ist ziemlich performant, wenn man nicht unnötig komplexe Regeln einbaut

Mit der oben von mir geposteten Transformation über den gesamten Datenbestand geht das auf einem Core Duo mit 1,6 GHz noch recht fix.
localhost:~ dan$ time ./dictransform.pl ../wadoku-top/webapp/src/main/webapp/xsl/entry_export_macdic.xslt wadoku.xml > /dev/null
real	3m35.808s
user	3m32.094s
sys	0m1.252s

Das Bauen des Mac-Dictionary hingegen braucht schon fast ne Stunde

Wenn du Speicherprobleme bekommst, solltest du bedenken, dass es meist nie eine gute Idee ist, das gesamte XML-Dokument im Speicher zu halten. Um den Speicherverbrauch im Rahmen zu halten, hab ich nen kleines Perl-skript, das jeweils nur einen <entry/> an libxslt übergibt. Etwa so
while ($record = <FILE>) {
        if ($record =~ /^<entry /) {
                $source = XML::LibXML->load_xml(string => $record);
                $results = $stylesheet->transform($source);
                $res = $stylesheet->output_as_bytes($results);
                $res =~ s/ xmlns:d="http:\/\/www.apple.com\/DTDs\/DictionaryService-1.0.rng" xmlns="http:\/\/www.w3.org\/1999\/xhtml" xmlns:wd="http:\/\/www.wadoku.de\/xml\/entry"//g;
                print $res;
                print "\n";
        }
}

無知の知
boscowitch



Joined: 23/09/2008 16:03:04
Messages: 231
Location: ケルン
Offline

hmm ja das mit dem jeweils nur 1 entry abbarbeiten mache ich auch so, die klassen sind ja entry iteratoren die einem dann immer das nächste entry schön als object geben um es zu verarbeiten und dann weiter zu lesen.

der XSL importer müsste dann auch so arbeiten, gut zu wissen das man da auch einzeln übergeben kann.

das problem beim XmlTextreader ist das das ganze parsing mnuell gemacht werden muss alla wo bin ich drinnen wenn das ende kommt ect.
aber dafür ist es ultra performant (ist super zum debuggen):


time ./wadoku wadoku.xml > new_gjiten.txt
real 0m14.434s
user 0m14.186s
sys 0m0.140s

(das is komplett gelesen und durch den GjitenExporter klasse zusammen gesetzt auf meine intel dual core 2,4 ghrz laptop)
leider is es wie gesagt sehr aufwendig und jede ausnahme der regel bzw parameter muss getrennt behandelt werden.
 
Forum Index » Japanisch auf PC/PDA
Go to: