Ada 95: Modifying output of dictionary program

Question

I've found this dictionary by William Whitaker on the Internet and I like its parsing capabilities. But the output doesn't fit for me.

The issue (challenge for me):

Given an input form such as "audiam", the program returns the following output (plain text):

audi.am              V      4 1 PRES ACTIVE  SUB 1 S    
audi.am              V      4 1 FUT  ACTIVE  IND 1 S    
audio, audire, audivi, auditus  V (4th)   [XXXAO]  
hear, listen, accept, agree with; obey; harken, pay attention; be able to hear;

But I just want to receive the following text output (same input: audiam):

audiam=audio, audire, audivi, auditus

That is:

InputWord=Dictionary_Forms

So some pieces of information are needless for me.

How can I change the output of this program by modifying the Ada code?

I don't have any Ada knowledge, but I know Delphi/Pascal so it's quite easy to understand the code, isn't it? So the parts causing the text output seem to be the TEXT_IO.PUT(...) statements, right? They're all called in list_package.adb so this is probably the source file to look at.

What has to be changed in particular?

The full Ada 95 source code of this program is available on this page.

I hope some of you are able to understand Ada 95 code. Thank you very much in advance!

My compiling problems:

For use on a windows machine, I downloaded MinGW and tried to compile the source files using "MinGW Shell". But this was my input and the shell's reponse:

MinGW Shell reponse

Compiling with the latest Cygwin version:

When I compile the program using the latest version of Cygwin, there is no error message:

enter image description here

There is even an .exe file which is created. Its size is 1.6 MB (1,682,616 bytes). But when I open it, it closes right away. What has gone wrong?

Should we assume the output is text ? is postprocessing the text not an option ? — NWS
I agree with @NWS, unless you're interested in learning Ada (and yes, a number of us here are able to understand Ada 95) I would just filter the output through some shell/Python/Perl/awk/whatever script. — Marc C
Thanks for these two comments :) Yes, the output is (plain) text. I added this information in the question above. And just filtering the output by some script (best: PHP) would be ok as well. But the better solution would - of course - be the modification of the Ada program. — caw
Filtering afterwards is quite a complex task as the output can have lots of different forms. So modifying the Ada code in advance to get the right output is by far more easy. And since I have average Delphi/Pascal knowledge, the Ada code is easy to understand. — caw
For reference, you can right-click on the shell window's title bar to mark text for copying. It's a little easier to redact that way. — trashgod

trashgod trashgod · Accepted Answer · 2011-04-20T19:44:10

William Whitaker's Words is a handy tool. You may be able to find a version already built for your platform. I've not changed the code, but you can alter some things using various parameters. It's even hosted online. If you get an Ada compiler, I've included the last Makefile I used. It's a little thin on abstraction, but it includes the essential steps to compile the program and utilities, along with the steps to build the dictionaries.

TARG = words
ARGS = -O

$(TARG): *.ad[bs]
    gnatmake $(TARG) $(ARGS)

all: $(TARG)
    gnatmake makedict $(ARGS)
    gnatmake makeinfl $(ARGS)
    gnatmake makestem $(ARGS)
    gnatmake makeefil $(ARGS)
    @echo Please make the dicitionary
    @echo ./makedict DICTLINE.GEN
    @echo ./makestem STEMLIST.GEN
    @echo ./makeefil EWDSLIST.GEN
    @echo ./makeinfl INFLECTS.GEN

debug:
    gnatmake -g $(TARG)

clean:
    rm -f *.o *.ali b~* core

cleaner: clean
    rm -f *.s makedict makeinfl makestem makeefil

cleanest: cleaner
    rm -f $(TARG)

Addendum: One approach is to use gcc 4.4.3 on Ubuntu 10.04 with the updated Makefile above. For convenience, I used VirtualBox to host the linux instance.

$ gcc --version
gcc (Ubuntu 4.4.3-4ubuntu5) 4.4.3
Copyright (C) 2009 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Here's a quick test using the title of my second favorite passage from Catulli Carmina.

$ ./words odi et amo
odi                  V      6 1 PRES ACTIVE  IMP 2 S    
odeo, odire, odivi(ii), -  V TRANS   [EXXCW]    Later
od.i                 V      4 1 PRES ACTIVE  IMP 2 S    
odio, odire, odivi, -  V (4th) TRANS   [FXXCF]    Medieval
hate; dislike; be disinclined/reluctant/adverse to; (usu. PREFDEF);
odi                  N      2 4 GEN S N                   Early   
odium, odi(i)  N (2nd) N   [XXXAO]  
hate/hatred/dislike/antipathy; odium, unpopularity; boredom/impatience;
hatred (manifested by/towards group), hostility; object of hate/odium;
od.i                 V      3 1 PERF ACTIVE  IND 1 S    
odi, odisse, osus  V (3rd) PERFDEF   [XXXBX]  
hate (PERF form, PRES force), dislike; be disinclined/reluctant/adverse to;

et                   CONJ                               
et  CONJ   [XXXAX]  
and, and even; also, even;  (et ... et = both ... and);

am.o                 V      1 1 PRES ACTIVE  IND 1 S    
amo, amare, amavi, amatus  V (1st)   [XXXAO]  
love, like; fall in love with; be fond of; have a tendency to;

Addendum: Once you've got it running, the problem of modifying it remains. A grep for Put_Line\( shows 629 hits; most are in line_stuff and list*. That's where I'd start. As you are learning Ada, there are several good tutorials here.

Ada 95: Modifying output of dictionary program

3 Answers