Index: _old/app/src/dgp/Makefile =================================================================== --- _old/app/src/dgp/Makefile (revision 1e121f45e2d091fcd34a893291b8453e350d5884) +++ _old/app/src/dgp/Makefile (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) @@ -1,2 +1,4 @@ + + SHELL = /bin/sh LIB_PATH=../../lib @@ -7,10 +9,10 @@ #vpath %.o . -CXXFLAGS = -O2 -static -fpermissive +CXXFLAGS = -O2 -static sources = main.cc grammar.cc symbol.cc mgraph.cc sgraph.cc dgp0.cc cmdline.cc \ $(COMMON_PATH)/common.cc global.cc -bin = dgp dgc canonize tre +bin = dgp # plik *.o sa umieszczane w podkatalogu o @@ -43,5 +45,6 @@ clean: - rm ${bin} ${objs} cmdline.cc cmdline.h *.d + rm ${bin} ${objs} cmdline.cc cmdline.h + rm -rf *.d prof: dgp Index: _old/app/src/dgp/canonize =================================================================== --- _old/app/src/dgp/canonize (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) +++ _old/app/src/dgp/canonize (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) @@ -0,0 +1,50 @@ +#!/usr/bin/perl + +#package: UAM TExt Tools +#component: canonize +#version: 1.0 +#author: Tomasz Obrebski + +use lib "/usr/local/lib/utt"; +use lib "$ENV{'HOME'}/.local/lib/utt"; + +use strict; +use Getopt::Long; +use attr; + + +my $help; + +GetOptions("help|h" => \$help); + +if($help) +{ + print <<'END' + +Transforms syntactic categories to their canonical form. + +Usage: canonize + +Options: + --help -h Help. + +END +; + exit 0; +} + +#$|=1; + +my %tra; + +while(<>) +{ + s/$attr::pos_re\/$attr::avlist_re/trans($&)/ge; + print; +} + +sub trans +{ + my $cat=shift; + exists($tra{$cat}) ? $tra{$cat} : ( $tra{$cat} = attr::canonize $cat ); +} Index: _old/app/src/dgp/dgc =================================================================== --- _old/app/src/dgp/dgc (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) +++ _old/app/src/dgp/dgc (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) @@ -0,0 +1,292 @@ +#!/usr/bin/perl + +#package: UAM Text Tools +#component: dgc (dg compiler) +#version: 1.0 +#author: Tomasz Obrebski + +# wymaga niejawnie programu canonize!!!! +use lib "/usr/local/lib/utt"; +use lib "$ENV{'HOME'}/.local/lib/utt"; + +use strict; +use Getopt::Long; +use Data::Dumper; +use attr; +use File::HomeDir; + +my $systemconfigfile='/usr/local/etc/utt/dgc.conf'; +my $userconfigfile=home()."/.utt/dgc.conf"; + +Getopt::Long::Configure('no_ignore_case_always'); + +my $help=0; +my $catfile=0; +my $dicfile=0; +my $gramfile=0; +my $outputfile=0; + +#read configuration files########################### +my $file; +foreach $file ($systemconfigfile, $userconfigfile){ + if(open(CONFIG, $file)){ + while () { + chomp; + s/#.*//; + s/^\s+//; + s/\s+$//; + next unless length; + my ($name, $value) = split(/\s*=\s*/, $_, 2); + if(($name eq "categories")or($name eq "c")){ + $catfile=$value; + } + elsif(($name eq "dictionary")or($name eq "d")){ + $dicfile=$value; + } + elsif(($name eq "grammar")or($name eq "g")){ + $gramfile=$value; + } + elsif(($name eq "outputfile")or($name eq "o")){ + $outputfile=$value; + } + elsif(($name eq "help")or($name eq "h")){ + $help=1; + } + + } + close CONFIG; + } +} +######################################################### + +GetOptions("help|h" => \$help, + "categories|c=s" => \$catfile, + "dictionary|d=s" => \$dicfile, + "grammar|g=s" => \$gramfile, + "outputfile|o=s" => \$outputfile); + +my $homedir = $ENV{'HOME'}; +$catfile =~ s/~/$homedir/; +$dicfile =~ s/~/$homedir/; +$gramfile =~ s/~/$homedir/; +$outputfile =~ s/~/$homedir/; + + +if($help) +{ + print <<'END' +Usage: dgc [OPTIONS] + +Options: + --categories -c filename List of syntactic categories. + --dictionary -d filename Dictionary. + --grammar -g filename List of grammar rules. + --outputfile -o filename Output file name. + --help -h Help. +END +; + exit 0; +} + +die("At least one of --cats and --dic must be given.\n") if !$catfile && !$dicfile; + +my $ncat=0; +my $nrole=0; +my $nsgl=0; +my $nleft=0; +my $nright=0; +my $nreq=0; +my $nlink=0; +my $nflag=0; + +my %cats; +my %roles; +my %agr; +my %gov; + +if(!$outputfile) { + *OUTPUT = *STDOUT; +} +elsif($outputfile eq "-") { + *OUTPUT = *STDOUT; +} +else { + open(OUTPUT, ">$outputfile") or die("Can't open output file: $outputfile!"); +} + + +loadcats($catfile) if $catfile; +extractcats($dicfile) if $dicfile; + + +my $cats_re = qr/(?:$attr::cat_re\s*(?:,\s*$attr::cat_re)*)/; + +# class parse_class: +# /$attr::cat_re/g; + + +if(!$gramfile) { + *INPUT = *STDIN; +} +elsif($gramfile eq "-"){ + *INPUT = *STDIN; +} +else { + open(INPUT, $gramfile) or die("Unable to open: $gramfile!"); +} + +while() +{ + s/#.*//; + s/^\s+//; + s/\s+$//; + if(/^AGR\s+(\S+)\s+(\S+)$/) + { + push @{$agr{$1}}, $2; + } + elsif(/^GOV\s+(\S+)\s+(\S+)$/) + { + push @{$gov{$1}}, attr::parse($2); + } + elsif(/^ROLE\s+\S+$/) + { + $roles{$_}=1; + print OUTPUT "$_\n"; + } + elsif(/^SGL\s+\S+$/) + { + ++$nsgl; + print OUTPUT "$_\n"; + } + elsif(/^REQ\s+(\S+)\s+(\S+)$/) + { + print OUTPUT "#$_\n"; + my $cat = attr::parse $1; + for my $atomcat (keys %cats) + { + if(attr::match @$cat, @{$cats{$atomcat}}) + { + print OUTPUT "REQ ".$atomcat." $2\n"; + ++$nreq; + } + } + } + elsif(/^LEFT\s+\S+$/) + { + ++$nleft; + print OUTPUT "$_\n"; + } + elsif(/^RIGHT\s+\S+$/) + { + ++$nright; + print OUTPUT "$_\n"; + } + elsif(my ($hs,$ds,$r) = /^LINK\s+($cats_re)\s+($cats_re)\s+(\S+)$/) + { + print OUTPUT "#$_\n"; + for my $h ($hs =~ /$attr::cat_re/g) + { + for my $d ($ds =~ /$attr::cat_re/g) + { + addlinks($h,$d,$r); + } + } + } + elsif(/^FLAG\s+\S+$/) + { + ++$nflag; + print OUTPUT "$_\n" + } + elsif(/^$/) { + # pomijamy puste linie oraz komentarze + } + else + { + print STDERR "Illegal format: $_\n"; + } +} + + +sub addlinks +{ + my ($h,$d,$r) = @_; + + for my $a (@{$agr{$r}}) { print OUTPUT "#AGR $r $a\n"; } + for my $c (@{$gov{$r}}) { print OUTPUT "#GOV $r ".attr::unparse(@$c)."\n"; } + my $head = attr::parse $h; + my $dep = attr::parse $d; + + for my $atomhead (keys %cats) + { + if(attr::match @$head, @{$cats{$atomhead}}) + { + DEP: + for my $atomdep (keys %cats) + { + next DEP if ! attr::match @$dep, @{$cats{$atomdep}}; + + for my $a (@{$agr{$r}}) + { + next DEP if ! attr::agree(@{$cats{$atomhead}},@{$cats{$atomdep}},$a); + } + + for my $c (@{$gov{$r}}) + { + next DEP if ! attr::match(@$c,@{$cats{$atomdep}}); + } + + print OUTPUT "LINK "; + print OUTPUT $atomhead." "; + print OUTPUT $atomdep." $r\n"; + ++$nlink; + + } + } + } +} + + +printf STDERR "%6d CAT statements\n", 0+keys(%cats); +printf STDERR "%6d ROLE statements\n", 0+keys(%roles); +printf STDERR "%6d SGL statements\n", $nsgl; +printf STDERR "%6d REQ statements\n", $nreq; +printf STDERR "%6d LEFT statements\n", $nleft; +printf STDERR "%6d RIGHT statements\n", $nright; +printf STDERR "%6d LINK statements\n", $nlink; +printf STDERR "%6d FLAG statements\n", $nflag; + + +sub extractcats +{ + my $file = shift; + open DICFILE, "canonize $file |"; + while() + { + while(/,([^[:space:];]+)/g) + { + my $cat=$1; + next if !$cat || exists $cats{$cat}; + $ncat++; + print OUTPUT "CAT $1\n"; + $cats{$cat}=attr::parse($cat); + } + } + close DICFILE; +} + + +sub loadcats +{ + my $file = shift; + open CATFILE, "canonize $file |"; + while() + { + tr/ \t\n//d; + next if !$_ || exists $cats{$_}; + print OUTPUT "CAT $_\n"; + ++$ncat; + $cats{$_}=attr::parse($_); + } + close CATFILE; +} + Index: _old/app/src/dgp/grammar.hh =================================================================== --- _old/app/src/dgp/grammar.hh (revision 1e121f45e2d091fcd34a893291b8453e350d5884) +++ _old/app/src/dgp/grammar.hh (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) @@ -11,4 +11,6 @@ #include "sgraph.hh" + +using namespace std; class Link Index: _old/app/src/dgp/mgraph.hh =================================================================== --- _old/app/src/dgp/mgraph.hh (revision 1e121f45e2d091fcd34a893291b8453e350d5884) +++ _old/app/src/dgp/mgraph.hh (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) @@ -7,4 +7,7 @@ #include "thesymbols.hh" #include "../common/common.h" + + +using namespace std; class MNode Index: _old/app/src/dgp/sgraph.hh =================================================================== --- _old/app/src/dgp/sgraph.hh (revision 1e121f45e2d091fcd34a893291b8453e350d5884) +++ _old/app/src/dgp/sgraph.hh (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) @@ -11,4 +11,6 @@ #include "thesymbols.hh" + +using namespace std; class MNode; Index: _old/app/src/dgp/thesymbols.hh =================================================================== --- _old/app/src/dgp/thesymbols.hh (revision 1e121f45e2d091fcd34a893291b8453e350d5884) +++ _old/app/src/dgp/thesymbols.hh (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) @@ -8,4 +8,7 @@ #include #include + + +using namespace std; typedef Symbol<1> Cat; Index: _old/app/src/dgp/tre =================================================================== --- _old/app/src/dgp/tre (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) +++ _old/app/src/dgp/tre (revision a6e708f37f1025d3fd1cd8a7fe87a6029d723cbe) @@ -0,0 +1,304 @@ +#!/usr/bin/ruby -I /usr/local/lib/utt -I $HOME/.local/lib/utt + +$: << "#{ENV['HOME']}/.local/lib/utt" +$: << "/usr/local/lib/utt" + +require 'getoptlong' +require 'seg.rb' + +opts = GetoptLong.new( +[ '--help', '-h', GetoptLong::NO_ARGUMENT ], +[ '--debug', '-d', GetoptLong::NO_ARGUMENT ], +[ '--format', '-F', GetoptLong::REQUIRED_ARGUMENT ], +[ '--info', '-I', GetoptLong::REQUIRED_ARGUMENT ], +[ '--only-trees','-t', GetoptLong::NO_ARGUMENT ]) + +$helptext= +"The program generates trees from the graph output by dgp. dgp must\n"+ +"must be run with '-i ds' option.\n\n"+ +"Command: tre [options]\n\n"+ +"Options:\n"+ +"--help -h Print help (this text) and exit.\n"+ +"--debug -d Verbose output. For developers only.\n"+ +"--format=s -F s Output format. Recognized values:\n"+ +" a root + list of arcs\n"+ +" p parenthesized notation\n"+ +" h human readable indented tree format\n"+ +" Multiple values are allowed. (default p)\n"+ +"--info=s -I s Information printed. Recognized values:\n"+ +" n node identifier\n"+ +" f surface form\n"+ +" m morphological information\n"+ +" l arc labels\n"+ +"--only-trees -t Do not copy input. Print trees only.\n" + +$DEBUG=false +$FORMAT='p' +$INFO='DEFAULT' +$ONLYTREES=false + +opts.each do |opt, arg| + case opt + when '--help' + print $helptext + exit 0 + when '--debug' + $DEBUG=true + when '--format' + $FORMAT=arg + when '--info' + $INFO=arg + when '--only-trees' + $ONLYTREES=true + else + print "Unknown option #{opt}. Ignored.\n" + end +end + +if $INFO=='DEFAULT' + case $FORMAT + when 'p','a' + $INFO='nl' + when 'h' + $INFO='fmnl' + end +end + +$dgpsep=';' + +def tre(input) + $gphid=[] + $form=[] + $lem=[] + nodes=[] + count=0 + seg=Seg.new + for line in input + print line unless $ONLYTREES + seg.set(line) + if dgp=seg['dgp'] + if nodes==[] && seg[3]!='BOS' + print "A sentence must start with BOS segment. Aborting.\n" + return + end + + id=dgp[/^\d+/].to_i + + if gph=seg['gph'] + $gphid[id]=gph[/^\d+/].to_i + else + print "No gph field. Aborting.\n" + return + end + + $form[$gphid[id]]=seg[4] + $lem[$gphid[id]]=seg['lem'] + + nodes[id] = [seg[1].to_i,dgp] + + if seg[3]=='EOS' + $pref = "#{seg[1]} #{seg[2]} SYN *" + parsegraph(nodes) + printgraph if $DEBUG + $thetrees=[] + gentrees2 + for t in $thetrees + count += 1 + t1=ground(t) + case $FORMAT + when /a/ + print "#{$pref} tre:#{count} arc:" + printarcs(t1[0],t1[1]) + print "\n" + when /p/ + print "#{$pref} tre:#{count} par:" + printpar(t1[0],t1[1]) + print "\n" + when /h/ + print "#\n# tree #{count}\n# ------\n" + printtree(t1[0],t1[1],0) + end + end + nodes=[] + end + end + end +end + + +def nodeinfo(id) + info="" + if $INFO =~ /n/ + info += id.to_s + info += '.' if $INFO =~ /[fm]/ + end + if $INFO =~ /f/ + info += $form[id] + info += ';' if $INFO =~ /m/ + end + if $INFO =~ /m/ + info += $lem[id] + end + info +end + + +def printarcs(root,arcs) + print nodeinfo(root) + for a in arcs + print ';' + print "#{a[2]}:" if $INFO =~ /l/ + print nodeinfo(a[0])+'-'+nodeinfo(a[1]) + end +end + +def printtree(root,arcs,o) + if o==0 + print "# %-16s" % "root: " + end + print nodeinfo(root),"\n" + for arc in arcs.select{ |a| a[0]==root }.sort{|a,b| a[1]<=>b[1] } + print '# '," "*(o+1) + print "%-16s" % (arc[2]+": ") + printtree(arc[1],arcs,o+1) + end +end + +def printpar(root,arcs) + print nodeinfo(root) + deps = arcs.select{ |a| a[0]==root }.sort{|a,b| a[1]<=>b[1] } + unless deps == [] + print '(' + cont=false + for arc in deps + if cont then print ',' else cont=true end + print arc[2],':' if $INFO =~ /l/ + printpar(arc[1],arcs) + end + print ')' + end +end + + +def parsegraph(nodes) + + $n =nodes.length + $sat =[]; + + $vis =[]; + $succ=[]; + $lhs =[]; + $arcs=[]; + $pos=[] + + for dgp in nodes + + parts = dgp[1].split($dgpsep,6) + + if parts[3]==nil || parts[4]==nil || parts[5]==nil + $stderr.print "ERR: tre requires dgp be called with '--info s' option. Aborting.\n" + exit + end + + i = parts[0].to_i + $pos[i] = dgp[0].to_i + $sat << i if parts[1]=="s" + $arcs |= parts[2].split(',').map{ |a| case a + when /\-\-(\w+)-(\d+)\/(\d+)/ + [i, $2.to_i, $1, $3.to_i] + when /\+\+(\d+)-(\w+)\/(\d+)/ + [$1.to_i, i, $2, $3.to_i] + end } + $succ |= parts[3][1..-2].split(',').map{|x| [x.to_i,i]} + $vis |= parts[4][1..-2].split(',').map{|x| [x.to_i,i]} + $lhs |= parts[5][1..-2].split(',').map{|x| [x.to_i,i]} + [[i,i]] + + end +end + + +def ground(t) + [ $gphid[t[0]] , t[1].map{|a| [$gphid[a[0]],$gphid[a[1]],a[2]]} ] +end + + +def gentrees2() + $thetrees=[]; + bos=0; eos=$n-1; + roots = (1...eos).select{|i| $vis.include? [i,eos]}.select{|i| $vis.include? [bos,i]} + if $DEBUG then print "ROOTS: #{roots.inspect}\n" end + for i in roots + $theroot=i + for r in buildR(i , eos, []) + (rmin,rmax,rtree) = r + buildR(bos, rmin, rtree) + end + end +end + + +def buildR(min, max, tree) + if $DEBUG then print "buildR--#{min}--#{max}--#{tree.inspect}\n" end + trees=[] + for a in $arcs.select{|a| a[0]==max && $vis.include?([min,a[1]]) } + if $DEBUG then print "ARC: #{a.inspect}\n" end + for r in buildR(a[1],a[3],tree+[a]) + (rmin,rmax,rarcs) = r + for l in buildR(min,rmin,rarcs) + (lmin,lmax,larcs) = l + trees << [lmin,rmax,larcs] + end + end + end + for i in (0...$n).select{|i| $succ.include?([i,max])}.select{|i| $lhs.include?([min,i])} + for l in buildL(min,i,tree) + (lmin,lmax,larcs) = l + trees << [lmin,lmax,larcs] + end + end + trees +end + + +def buildL(min,max,tree) + if $DEBUG then print "buildL--#{min}--#{max}--#{tree.inspect}\n" end + if $pos[min]==$pos[max] + if min==0 && max==0 + $thetrees.push [$theroot,tree] + if $DEBUG then print "adding tree: #{tree.inspect}\n" end + end + return [[max,max,tree]] + end + trees=[] + for arc in $arcs.select{|a| a[1]==max && $lhs.include?([min,a[0]]) } + if $DEBUG then print "ARC: #{arc.inspect}\n" end + for r in buildR(arc[3],max,tree+[arc]) + (rmin,rmax,rarcs) = r + for l in buildL(min,rmin,rarcs) + (lmin,lmax,larcs) = l + trees << [lmin,lmax,larcs] + end + end + end + trees +end + + +def printgraph() + + print "N: #{$n}\n" + print "SAT: #{set_to_s($sat)}\n" + print "SUCC: #{rel_to_s($succ)}\n" + print "VIS: #{rel_to_s($vis)}\n" + print "LHS: #{rel_to_s($lhs)}\n" + print "ARCS: #{arcs_to_s($arcs)}\n" +end + +def set_to_s(s) "{#{s.join(',')}}" end +def rel_to_s(r) "{#{r.map{|p| "(#{p[0]},#{p[1]})"}.join(',')}}" end +def arc_to_s(q) "-#{q[0]}-#{q[2]}-#{q[1]}/#{q[3]}" end +def arcs_to_s(a) "{#{a.map{|q| arc_to_s(q)}.join(',')}}" end + +###################################################################### + +tre($stdin)